Le bloc "finally" de C# s'exécute-t-il TOUJOURS ?

Question

Duplicata possible :
Le code contenu dans une instruction Finally sera-t-il ignoré si je renvoie une valeur dans un bloc Try ?

Considérons le code C# suivant. Le bloc "finally" s'exécute-t-il ?

public void DoesThisExecute() {
   string ext = "xlsx";
   string message = string.Empty;
   try {
      switch (ext) {
         case "xls": message = "Great choice!"; break;
         case "csv": message = "Better choice!"; break;
         case "exe": message = "Do not try to break me!"; break;
         default:
            message = "You will not win!";
            return;
      }
   }
   catch (Exception) {
      // Handle an exception.
   }
   finally {
      MessageBox.Show(message);
   }
}

Ha, après avoir fini d'écrire ceci, j'ai réalisé que j'aurais pu faire ce test moi-même dans Visual Studio. Cependant, n'hésitez pas à répondre !

Answer 1

Non, ce n'est pas le cas. Il s'exécutera toujours si l'application est toujours en cours d'exécution (sauf pendant une interruption de service). FastFail exception, Lien MSDN (comme d'autres l'ont fait remarquer). Il s'exécutera lorsqu'il sortira de la partie try/catch du bloc.

Il ne s'exécutera PAS si l'application tombe en panne, si elle est tuée par une commande kill process, etc. C'est très important, car si vous écrivez du code qui attend absolument qu'il s'exécute, par exemple en effectuant manuellement un roll back, et s'il ne s'exécute pas autrement, il s'engage automatiquement, vous pouvez vous retrouver dans un scénario où l'application s'arrête avant que cela ne se produise. Honnêtement, il s'agit d'un scénario extérieur, mais il est important d'en tenir compte dans ces situations.

Answer 2

Extrait de la spécification MSDN C# de la try déclaration :

Les déclarations d'un finally sont toujours exécutés lorsque le contrôle quitte un bloc try déclaration. Cela est vrai, que le transfert de contrôle se produise à la suite d'une exécution normale, à la suite de l'exécution d'une instruction break , continue , goto o return ou à la suite de la propagation d'une exception à partir de l'instruction try déclaration.

Source :

Il y a des cas où le bloc final ne s'exécutera pas :

1. Environnement.FailFast
2. Types d'exceptions non rattrapables
3. Panne d'électricité

Answer 3

Il n'est pas totalement vrai que finally sera toujours exécuté. Voir cette réponse de Haacked :

Deux possibilités :

• StackOverflowException
• ExecutingEngineException

Le bloc final ne sera pas exécuté lorsqu'il y a une StackOverflowException puisqu'il n'y a pas de place sur la pile pour pour exécuter du code supplémentaire. Il ne sera ne sera pas non plus appelé en cas d'exception d'une ExecutingEngineException, ce qui est très rare.

En fait, pour toute sorte d'exception asynchrone (telle que StackOverflowException , OutOfMemoryException , ThreadAbortException ) l'exécution d'un finally n'est pas garanti.

Cependant, ces exceptions sont des exceptions dont vous ne pouvez généralement pas vous remettre, et dans la plupart des cas, votre processus se terminera de toute façon.

En fait, il y a aussi au moins un autre cas où finally n'est pas exécuté comme décrit par Brian Rasmussen dans un maintenant question supprimée :

L'autre cas que je connais est celui où un finaliseur lève une exception. Dans ce cas, le processus cas, le processus est terminé immédiatement aussi, et donc la garantie garantie ne s'applique pas.

Le code ci-dessous illustre le problème

static void Main(string[] args) {
   try {
      DisposableType d = new DisposableType();
      d.Dispose();
      d = null;
      GC.Collect();
      GC.WaitForPendingFinalizers();
   } catch {
      Console.WriteLine("catch");
   } finally {
      Console.WriteLine("finally");
   }
}

public class DisposableType : IDisposable {
   public void Dispose() {
   }

   ~DisposableType() {
      throw new NotImplementedException();
   }
}

Un try/catch/finally fiable devra utiliser Régions d'exécution sous contrainte (CER) . Un site exemple est fourni par MSDN :

[StructLayout(LayoutKind.Sequential)]
struct MyStruct
{
    public IntPtr m_outputHandle;
}

sealed class MySafeHandle : SafeHandle
{
    // Called by P/Invoke when returning SafeHandles
    public MySafeHandle()
        : base(IntPtr.Zero, true)
    {
    }

    public MySafeHandle AllocateHandle()
    {
        // Allocate SafeHandle first to avoid failure later.
        MySafeHandle sh = new MySafeHandle();

        RuntimeHelpers.PrepareConstrainedRegions();
        try { }
        finally
        {
            MyStruct myStruct = new MyStruct();
            NativeAllocateHandle(ref myStruct);
            sh.SetHandle(myStruct.m_outputHandle);
        }

        return sh;
    }
}

L'article suivant constitue une excellente source d'information :

Meilleures pratiques en matière de fiabilité

Answer 4

De MSDN try-finally (Référence C#)

Le bloc finally est utile pour nettoyer les ressources allouées dans le bloc le bloc try ainsi que pour exécuter tout code qui doit s'exécuter même s'il y a une exception. Le contrôle est toujours transmis au bloc finally, quelle que soit de la façon dont le bloc try sort .

Answer 5

Oui, c'est vrai :-) http://msdn.microsoft.com/en-us/library/zwc8s4fz.aspx