Rozpocząć, uratować i zapewnić w Ruby?

Tak, ensure zapewnia, że kod jest zawsze oceniany. Dlatego nazywa się ensure. Jest więc odpowiednikiem Javy i C#finally.

Ogólny przepływ begin/rescue/else/ensure/end wygląda tak:

begin
  # something which might raise an exception
rescue SomeExceptionClass => some_variable
  # code that deals with some exception
rescue SomeOtherException => some_other_variable
  # code that deals with some other exception
else
  # code that runs only if *no* exception was raised
ensure
  # ensure that this code always runs, no matter what
  # does not change the final value of the block
end

Możesz pominąć rescue, ensure lub else. Możesz również pominąć zmienne, w takim przypadku nie będziesz mógł sprawdzić wyjątku w kodzie obsługi wyjątków. (Cóż, zawsze możesz użyć zmiennej Global exception, aby uzyskać dostęp do ostatniego wyjątku to było podniesione, ale to trochę za trudne.) I możesz pominąć klasę exception, w którym to przypadku wszystkie wyjątki dziedziczone z StandardError zostaną przechwycone. (Proszę zauważyć, że nie oznacza to, że wszystkie wyjątki są przechwytywane, ponieważ istnieją wyjątki, które są instancjami Exception, ale nie StandardError. Głównie bardzo poważne wyjątki, które zagrażają integralności programu, takie jak SystemStackError, NoMemoryError, SecurityError, NotImplementedError, LoadError, SyntaxError, ScriptError, Interrupt, SignalException lub SystemExit.)

Niektóre bloki tworzą ukryte bloki WYJĄTKÓW. Na przykład definicje metod są domyślnie również blokami WYJĄTKÓW, więc zamiast pisać

def foo
  begin
    # ...
  rescue
    # ...
  end
end

Piszesz tylko

def foo
  # ...
rescue
  # ...
end

Lub

def foo
  # ...
ensure
  # ...
end

To samo dotyczy definicji class i definicji module.

Jednak w konkretnym przypadku, o który pytasz, istnieje znacznie lepszy idiom. Ogólnie rzecz biorąc, gdy pracujesz z jakimś zasobem, który musisz wyczyścić na końcu, robisz to przekazując blok do metody, która robi wszystko za Ciebie. Jest podobny do bloku using W C#, z tym że Ruby jest na tyle potężny, że nie musisz czekać, aż arcykapłani Microsoftu zejdą z góry i łaskawie zmienią za Ciebie kompilator. W Ruby możesz po prostu zaimplementować go samodzielnie:

# This is what you want to do:
File.open('myFile.txt', 'w') do |file|
  file.puts content
end

# And this is how you might implement it:
def File.open(filename, mode='r', perm=nil, opt=nil)
  yield filehandle = new(filename, mode, perm, opt)
ensure
  filehandle&.close
end

I co wiecie: to jest już dostępne w Bibliotece Głównej jako File.open. Ale jest to ogólny wzór, który można wykorzystać w swoim własny kod, jak również, do implementacji wszelkiego rodzaju czyszczenia zasobów (à la using W C#) lub transakcji lub cokolwiek innego można myśleć.

Jedyny przypadek, w którym to nie działa, jeśli pozyskiwanie i zwalnianie zasobów jest dystrybuowane w różnych częściach programu. Ale jeśli jest zlokalizowany, jak w twoim przykładzie, możesz łatwo użyć tych bloków zasobów.

BTW: w nowoczesnym C#, using jest rzeczywiście zbędny, ponieważ można zaimplementować bloki zasobów w stylu Ruby siebie:

class File
{
    static T open<T>(string filename, string mode, Func<File, T> block)
    {
        var handle = new File(filename, mode);
        try
        {
            return block(handle);
        }
        finally
        {
            handle.Dispose();
        }
    }
}

// Usage:

File.open("myFile.txt", "w", (file) =>
{
    file.WriteLine(contents);
});