Question

我正在寻找scala中Execute Around方法模式的实现，并找到以下内容（使用我的次要mods）：

class Resource private() {
  private def dispose() { println("Cleaning up...") }

  def example = {
      println("Function body")
  }

}
object Resource {
  def using(codeBlock: Resource => Unit) {
    val run = new Resource
    try {
      codeBlock(run)
    }
    finally {
      run.dispose()
    }
  }
}


Resource.using { run =>  run.example }

然后我再次考虑将它用于我的特定应用程序，因为在我的所有类中都有很多样板代码。

我想知道更有经验的scala专家是否能够创建一个类似的模式，并包装整个对象，当对象超出范围时调用清理方法？这与C＃using（）块类似，我是通过将Disposable trait混合到支持此方法的对象来实现的吗？

示例目标：

trait Disposable { def dispose }
class a extends Disposable

[some helper object unrelated to a?].using (a) { 

} // automatically call a.dispose() at end of scope?

Answer 1

从这个blog post开始，您可以通过这种方式实现类似Java的尝试：

class Loan[A <: AutoCloseable](resource: A) {
  def to[B](block: A => B) = {
    var t: Throwable = null
    try {
      block(resource)
    } catch {
      case x: Exception => t = x; throw x
    } finally {
      if (resource != null) {
        if (t != null) {
          try {
            resource.close()
          } catch {
            case y: Exception => t.addSuppressed(y)
          }
        } else {
          resource.close()
        }
      }
    }
  }
}

object Loan {
  def loan[A <: AutoCloseable](resource: A) = new Loan(resource)
}

你会像这样使用它：

loan (new PrintWriter(new File("file"))) to (_ println "Hello world!\n")

使用Java AutoCloseable接口意味着您的对象可以在Java try-with-resources块中使用，并且您可以将助手与标准的Java AutoCloseable事物（如IO流）一起使用。

Execute Around Method模式

1 个答案: