Commencer, de Sauvetage et d'Assurer à Ruby?

Oui, ensure assure que le code est toujours évalué. C'est pourquoi il est appelé ensure. Donc, il est équivalent à Java et C#'s finally.

Le flux général de begin/rescue/else/ensure/end ressemble à ceci:

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

Vous pouvez laisser de côté rescue, ensure ou else. Vous pouvez également laisser les variables dans ce cas, vous ne serez pas en mesure d'inspecter l'exception dans votre code de gestion des exceptions. (Eh bien, vous pouvez toujours utiliser le mondial exception de la variable pour accéder à la dernière exception qui a été soulevée, mais c'est un peu hacky.) Et vous pouvez le laisser sortir de la classe d'exception, auquel cas toutes les exceptions qui héritent de StandardError sera pris. (Veuillez noter que cela ne signifie pas que tous exceptions sont pris, car il y a des exceptions qui sont des instances de Exception mais pas StandardError. Pour la plupart très grave exceptions qui compromettent l'intégrité du programme, telles que SystemStackError, NoMemoryError, SecurityError, NotImplementedError, LoadError, SyntaxError, ScriptError, Interrupt, SignalException ou SystemExit.)

Certains blocs de la forme implicite blocs d'exception. Par exemple, les définitions de méthode sont implicitement aussi des blocs d'exception, donc au lieu d'écrire

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

vous écrire juste

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

ou

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

La même chose s'applique à class définitions et module définitions.

Toutefois, dans le cas précis que vous me demandez, il n'y a en fait un bien meilleur idiome. En général, lorsque vous travaillez avec des ressources dont vous avez besoin pour nettoyer à la fin, vous ne faites que par le passage d'un bloc à une méthode qui fait tout le nettoyage pour vous. Il est semblable à un using bloc en C#, à l'exception que Ruby est en fait assez puissant pour que vous n'avez pas à attendre pour les grands prêtres de Microsoft à descendre de la montagne et ont gracieusement accepté de changer leur compilateur pour vous. En Ruby, vous pouvez simplement mettre en œuvre vous-même:

# 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

Et vous savez quoi: c'est déjà disponibles dans la bibliothèque de base comme File.open. Mais c'est une tendance générale que vous pouvez utiliser dans votre propre code ainsi, pour la mise en œuvre de toute forme de ressource de nettoyage (à la using en C#) ou les transactions ou ce que vous pourriez penser.

Le seul cas où cela ne fonctionne pas, si l'acquisition et de libérer les ressources sont réparties sur les différentes parties du programme. Mais si c'est localisé, dans votre exemple, vous pouvez facilement utiliser ces ressources blocs.

---

BTW: moderne C#, using est en fait superflue, parce que vous pouvez mettre en œuvre Ruby-style de ressources blocs-vous:

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

Si vous voulez vous assurer qu'un fichier est fermé, vous devez utiliser la forme de bloc de File.open:

File.open("myFile.txt", "w") do |file|
  begin
    file << "#{content} \n"
  rescue
  #handle the error here
  end
end

Oui, ensure permet d'exécuter à chaque fois, de sorte que vous n'avez pas besoin de la file.close dans le begin bloc.

Par ailleurs, un bon moyen de tester est de le faire:

begin
  # Raise an error here
  raise "Error!!"
rescue
  #handle the error here
ensure
  p "=========inside ensure block"
end

Vous pouvez tester pour voir si "=========à l'intérieur de veiller à bloc" sera imprimé quand il y a une exception.
Ensuite, vous pouvez mettre en commentaire l'instruction qui génère l'erreur et de voir si le ensure instruction est exécutée par voir si quelque chose est imprimé.

Oui, ensure comme finally garantit que le bloc sera exécuté. Ceci est très utile pour s'assurer que les ressources critiques sont protégés par exemple, la fermeture d'un descripteur de fichier en cas d'erreur, ou la libération d'un mutex.