"mit" - Funktion

Ich habe darüber nachgedacht und ich dachte, vielleicht gab es einen anderen Weg, um diese Probleme anzugehen. Hier ist mein nehmen auf die Unterstützung von "eine beliebige Anzahl" der Parameter (begrenzt durch das, was Tupeln liefern):

object UsingTest {

  type Closeable = {def close():Unit }

  final class CloseAfter[A<:Product](val x: A) {
    def closeAfter[B](block: A=>B): B = {
      try {
        block(x);
      } finally {
        for (i <- 0 until x.productArity) {
          x.productElement(i) match { 
            case c:Closeable => println("closing " + c); c.close()
            case _ => 
          }
        }
      }
    }
  }

  implicit def any2CloseAfter[A<:Product](x: A): CloseAfter[A] = 
    new CloseAfter(x)

  def main(args:Array[String]): Unit = {
    import java.io._

    (new BufferedReader(new FileReader("in.txt")), 
     new PrintWriter("out.txt"),
     new PrintWriter("sample.txt")) closeAfter {case (in, out, other) => 
      out.println(in.readLine) 
      other.println("hello world!")
    }
  }
}

Ich glaube, ich bin die Wiederverwendung der Tatsache, dass 22 Tupel/Produkt-Klassen geschrieben wurden, in der Bibliothek... ich glaube nicht, dass diese syntax ist übersichtlicher als mit verschachtelte using (kein Wortspiel beabsichtigt), aber es war ein Interessantes Rätsel.

edit: ersetzt das val Belegung mit case (in, out, other) wie vorgeschlagen von retronym.

Hier ist ein Beispiel, in dem Sie die scala für das Verständnis, wie eine automatische Ressourcen-management-block für jedes Element, das eine java.io.Verschließbar, aber es könnte leicht erweitert werden, um für jedes Objekt mit einer close-Methode.

Diese Nutzung scheint ziemlich nah an die using-Anweisung und erlaubt Sie zu leicht zu haben, wie viele Ressourcen in einem block, wie Sie möchten.

object ResourceTest{
  import CloseableResource._
  import java.io._

  def test(){
    for( input <- new BufferedReader(new FileReader("/tmp/input.txt")); output <- new FileWriter("/tmp/output.txt") ){
      output.write(input.readLine)
    }
  }
}

class CloseableResource[T](resource: =>T,onClose: T=>Unit){
  def foreach(f: T=>Unit){
    val r = resource
    try{
      f(r)
    }
    finally{
      try{
        onClose(r)
      }
      catch{
        case e =>
          println("error closing resource")
          e.printStackTrace
      }
    }
  }
}

object CloseableResource{
  implicit def javaCloseableToCloseableResource[T <: java.io.Closeable](resource:T):CloseableResource[T] = new CloseableResource[T](resource,{_.close})
}

Ist es eine gute Idee, um detatch der cleanup-Algorithmus aus dem Programm Pfad.

Dieser Lösung können Sie sammeln closeables in einem Bereich.

Den Umfang der Bereinigung passieren wird, nachdem sich der block ausgeführt wird, oder der Bereich kann abgetrennt werden. Die Reinigung der Rahmen kann dann später erfolgen.

Diese Weise erhalten wir den gleichen Komfort ohne Beschränkung auf single-thread-Programmierung.

Die utility-Klasse:

import java.io.Closeable

object ManagedScope {
  val scope=new ThreadLocal[Scope]();
  def managedScope[T](inner: =>T):T={
    val previous=scope.get();
    val thisScope=new Scope();
    scope.set(thisScope);
    try{
      inner
    } finally {
      scope.set(previous);
      if(!thisScope.detatched) thisScope.close();
    }
  }

  def closeLater[T <: Closeable](what:T): T = {
    val theScope=scope.get();
    if(!(theScope eq null)){
      theScope.closeables=theScope.closeables.:+(what);
    }
    what;
  }

  def detatchScope(): Scope={
    val theScope=scope.get();
    if(theScope eq null) null;
    else {
      theScope.detatched=true;
      theScope;
    }
  }
}

class Scope{
  var detatched=false;
  var closeables:List[Closeable]=List();

  def close():Unit={
    for(c<-closeables){
      try{
        if(!(c eq null))c.close();
      } catch{
        case e:Throwable=>{};
      }
    }
  }
}

Die Verwendung:

  def checkSocketConnect(host:String, portNumber:Int):Unit = managedScope {
    //The close later function tags the closeable to be closed later
    val socket = closeLater( new Socket(host, portNumber) );
    doWork(socket);
  }

  def checkFutureConnect(host:String, portNumber:Int):Unit = managedScope {
    //The close later function tags the closeable to be closed later
    val socket = closeLater( new Socket(host, portNumber) );
    val future:Future[Boolean]=doAsyncWork(socket);

    //Detatch the scope and use it in the future.
    val scope=detatchScope();
    future.onComplete(v=>scope.close());
  }

Ab Scala 2.13 die standard-Bibliothek bietet eine dedizierte Ressource management utility: Mit.

Genauer gesagt, die Mit#Manager kann verwendet werden, wenn es mit mehreren Ressourcen.

In unserem Fall können wir die Verwaltung verschiedener Ressourcen wie Ihre PrintWriter oder BufferedReader, wie Sie implementieren beide AutoCloseable, um Lesen und schreiben aus einer Datei in eine andere, und, egal was, und schließen Sie die Eingangs-und die Ausgangs-Ressource danach:

import scala.util.Using
import java.io.{PrintWriter, BufferedReader, FileReader}

Using.Manager { use =>

  val in  = use(new BufferedReader(new FileReader("input.txt")))
  val out = use(new PrintWriter("output.txt"))

  out.println(in.readLine)
}
//scala.util.Try[Unit] = Success(())