var s = f.OpenRead(); // нененене, Дэвид Блейн!
var buf = new byte[1024]; // уйди, демон!
s.Read(buf, 0, buf.Length); // мы же забыли вызвать Dispose!

/// А теперь немного уличной магии:
f.OpenRead(s => { 
        var buf = new byte[1024];
        s.Read(buf, 0, buf.Length);
}); // я сделал вам Dispose(),
// осталось скукожить "обычный" OpenRead!

public static class FileHelper
{
    public static void OpenRead(this FileInfo fi, Action<FileStream> action)
    {
        using (var s = fi.OpenRead())
            action(s);
    }
}

// Scala - есть готовый finally - все просто
def withResource[A](f : Resource => A) : A = {
    val r = getResource()  // Replace with the code to acquire the resource
    try {
        f(r)
    } finally {
        r.dispose()
    }
}

//Client code becomes very simple:
withResource{ r =>
    // do stuff with r....
}

// SML
// First of all, a function such as 
  fun finally (thunk, effect) = 
      (((fn x => fn () => x) (thunk ()) 
        handle e => fn () => raise e) o effect) () 
// can be provided to make sure that a given effect will be performed after a 
// given thunk returns - whether normally or by raising an exception. 
// It is customary to provide functions that allocate a resource, pass the 
// resource to a given body function, and take care of deallocating the 
// resource.  For example, one could provide the function 
  fun withInputString string = 
      fn body => 
         let 
            val instream = TextIO.openString string 
         in 
            finally (fn () => body instream, 
                     fn () => TextIO.closeIn instream) 
         end 
// for executing a body with an instream that reads from a string.   
// Another example of such a scoped resource management function could be 
  fun withDirStream path = 
      fn body => 
         let 
            val dirstream = OS.FileSys.openDir path 
         in 
            finally (fn () => body dirstream, 
                     fn () => OS.FileSys.closeDir dirstream) 
         end 
// for executing a body with a directory stream.  As you can see, there is 
// some duplication in structure between the above two functions that could 
// easily be factored out, but I'll ignore that aspect in this article.

--// "библиотечная" функция 
--//  pcall - это аналог try-catch
local function unwind_protect(thunk,cleanup)  
  local ok, result = pcall(thunk)  
  if cleanup then cleanup() end  
  if not ok then 
    error(res,0)  -- // rethrow exception 
  else 
    return result 
  end 
end  

--// общая функция для работы с открытыми файлами  
local function with_open_file(name,mode)  
  return function(body)  
           local f = assert(io.open(name,mode))  
           return unwind_protect(function()return body(f) end,  
                                 function()return f and f:close() end)  
         end  
end  

--// usage: os-copy --   
function os_copy2(source_path,dest_path)  
  return with_open_file(source_path,"rb") (function(source)  
    return with_open_file(dest_path,"wb") (function(dest)  
      assert(dest:write(assert(source:read("*a"))))  
      return 'copy ok'  
    end)  
  end)  
end

class File
   def File.open_and_process(*args)
     f = File.open(*args)
     yield f
     f.close()
   end
end

File.open_and_process("file", "r") do |file|
  while line = file.gets
   puts line
  end
end

def withResource(f):
    resource = open('decor1.py')
    try:
        f(resource)
    finally:
        resource.close()
        
def readlines(resource):
    for line in resource:
        print line

withResource(readlines)

bracket open close action = do
    h <- open
    action h
    close h

withFile name action = bracket (openFile name) closeHandle action

copy a b = withFile a $
    \ah -> withFile b $ \bh -> read ah >>= \text -> write bh text

template<typename F>
void do(F f)
{
 before();
 try { f(); } catch(...) { }
 after();
}

{
  std::ifstream f("1.txt");
  // работаем с файлом
  ...
  //закрытие файла при уничтожении переменной f
}