Kaynak Yönetimi alternatifleri Scala için ne var Otomatik?

SORU

5 ŞUBAT 2010, Cuma

Kaynak Yönetimi alternatifleri Scala için ne var Otomatik?

Scala için web üzerinde KOL pek çok örnek (otomatik kaynak yönetimi) gördüm. Çoğu birbirlerine oldukça benziyorlardı bak ama rite-of-passage bir bir yazmak gibi görünüyor. Benyaptıçok güzel bir örnek devamı olsa da kullanma.

Ne olursa, bir sürü kod vardır kusurları bir tür ya da başka, ben de düşündüm ki, bu iyi bir fikir olabilir bir referans burada Yığın Taşması, nerede oy verebilirsiniz en doğru ve uygun sürümleri.

CEVAP

8 ŞUBAT 2010, PAZARTESİ

Chris Hansen blog entry 'ARM Blocks in Scala: Revisited' from 3/26/09 Odersky FOSDEM presentation Martin ile ilgili slayt 21 bahsediyor. Bir sonraki blok düz slayt 21 (izni ile) alınmıştır:

def using[T <: { def close() }]
    (resource: T)
    (block: T => Unit) 
{
  try {
    block(resource)
  } finally {
    if (resource != null) resource.close()
  }
}

--son-- alıntı

Peki, o zaman şöyle diyebiliriz:

using(new BufferedReader(new FileReader("file"))) { r =>
  var count = 0
  while (r.readLine != null) count  = 1
  println(count)
}

Bu yaklaşımın dezavantajları nelerdir? Bu desen otomatik kaynak yönetimi ihtiyacım yeri � adres gibi görünüyor

Düzenleme:eklenen kod parçası

Edit2:tasarım desen with deyimi python ve adresleme ilham alarak genişletme:

blok önce çalıştırmak için ifadeler
yeniden atma istisna yönetilen kaynak bağlı
tek bir deyim ile iki kaynak kullanma
özel kaynak kullanım örtülü bir dönüştürme ve Managed bir sınıf sağlayarak

Bu Scala 2.8.

trait Managed[T] {
  def onEnter(): T
  def onExit(t:Throwable = null): Unit
  def attempt(block: => Unit): Unit = {
    try { block } finally {}
  }
}

def using[T <: Any](managed: Managed[T])(block: T => Unit) {
  val resource = managed.onEnter()
  var exception = false
  try { block(resource) } catch  {
    case t:Throwable => exception = true; managed.onExit(t)
  } finally {
    if (!exception) managed.onExit()
  }
}

def using[T <: Any, U <: Any]
    (managed1: Managed[T], managed2: Managed[U])
    (block: T => U => Unit) {
  using[T](managed1) { r =>
    using[U](managed2) { s => block(r)(s) }
  }
}

class ManagedOS(out:OutputStream) extends Managed[OutputStream] {
  def onEnter(): OutputStream = out
  def onExit(t:Throwable = null): Unit = {
    attempt(out.close())
    if (t != null) throw t
  }
}
class ManagedIS(in:InputStream) extends Managed[InputStream] {
  def onEnter(): InputStream = in
  def onExit(t:Throwable = null): Unit = {
    attempt(in.close())
    if (t != null) throw t
  }
}

implicit def os2managed(out:OutputStream): Managed[OutputStream] = {
  return new ManagedOS(out)
}
implicit def is2managed(in:InputStream): Managed[InputStream] = {
  return new ManagedIS(in)
}

def main(args:Array[String]): Unit = {
  using(new FileInputStream("foo.txt"), new FileOutputStream("bar.txt")) { 
    in => out =>
    Iterator continually { in.read() } takeWhile( _ != -1) foreach { 
      out.write(_) 
    }
  }
}

Bunu Paylaş: