Начать, спасти и убедиться в Ruby?

Да, убедитесь, что гарантирует, что код всегда оценивается. Вот почему он называется гарантировать . Таким образом, он эквивалентен Java и C # finally .

Общий поток begin / rescue / else / sure / end выглядит следующим образом:

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

Вы можете не указывать спасение , обеспечение или иначе . Вы также можете не указывать переменные, и в этом случае вы не сможете проверить исключение в коде обработки исключений. (Что ж, вы всегда можете использовать глобальную переменную исключения для доступа к последнему исключению, которое было вызвано, но это немного взломано.) И вы можете опустить класс исключения, и в этом случае все исключения, наследуемые от StandardError будет пойман.(Обратите внимание, что это не означает, что все исключения перехватываются, потому что есть исключения, которые являются экземплярами Exception , но не StandardError . В основном это очень серьезные исключения, которые нарушить целостность программы, например SystemStackError , NoMemoryError , SecurityError , NotImplementedError , LoadError , ] SyntaxError , ScriptError , Прерывание , SignalException или SystemExit .)

Некоторые блоки образуют неявные блоки исключений. Например, определения методов неявно также являются блоками исключений, поэтому вместо записи

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

вы пишете только

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

или

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

. То же самое относится к определениям класса и определениям модуля .

Однако в конкретном случае, о котором вы спрашиваете, на самом деле есть гораздо лучшая идиома. В общем, когда вы работаете с некоторым ресурсом, который вам нужно очистить в конце, вы делаете это, передавая блок методу, который выполняет всю очистку за вас. Он похож на блок с использованием в C #, за исключением того, что Ruby на самом деле достаточно мощный, чтобы вам не приходилось ждать, пока высшие жрецы Microsoft спустятся с горы и любезно поменяют за вас свой компилятор. В Ruby вы можете просто реализовать это самостоятельно:

# 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

И что вы знаете: это уже доступно в основной библиотеке как File.open .Но это общий шаблон, который вы также можете использовать в своем собственном коде для реализации любого вида очистки ресурсов (а-ля с использованием в C #) или транзакций или чего-то еще, о чем вы можете подумать.

Единственный случай, когда это не работает, если получение и освобождение ресурса распределяются по разным частям программы. Но если он локализован, как в вашем примере, вы можете легко использовать эти блоки ресурсов.

Кстати: в современном C # использование фактически излишне, потому что вы можете реализовать блоки ресурсов в стиле Ruby самостоятельно:

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);
});