Pourquoi utiliser finally en C# ?

Question

Ce qui se trouve à l'intérieur des blocs finally est exécuté (presque) toujours, alors quelle est la différence entre y enfermer du code ou le laisser non fermé ?

Answer 1

Le code contenu dans un bloc final sera exécuté, qu'il y ait ou non une exception. Cela s'avère très pratique lorsqu'il s'agit de certaines fonctions de gestion courante que vous devez toujours exécuter, comme la fermeture des connexions.

Maintenant, je suis deviner votre question est de savoir pourquoi vous devriez le faire :

try
{
    doSomething();
}
catch
{
    catchSomething();
}
finally
{
    alwaysDoThis();
}

Quand vous pouvez le faire :

try
{
    doSomething();
}
catch
{
    catchSomething();
}

alwaysDoThis();

La réponse est que, bien souvent, le code contenu dans l'instruction catch relancera une exception ou sortira de la fonction en cours. Dans ce dernier cas, l'appel "alwaysDoThis() ;" ne s'exécutera pas si le code contenu dans l'instruction catch émet un retour ou lance une nouvelle exception.

Answer 2

La plupart des avantages de l'utilisation de try-finally ont déjà été soulignés, mais j'ai pensé ajouter celui-ci :

try
{
    // Code here that might throw an exception...

    if (arbitraryCondition)
    {
        return true;
    }

    // Code here that might throw an exception...
}
finally
{
    // Code here gets executed regardless of whether "return true;" was called within the try block (i.e. regardless of the value of arbitraryCondition).
}

Ce comportement le rend très utile dans diverses situations, en particulier lorsque vous devez effectuer un nettoyage (disposer de ressources), bien qu'une en utilisant Le bloc est souvent préférable dans ce cas.

Answer 3

À chaque fois que vous utilisez des requêtes de code non gérées comme des lecteurs de flux, des requêtes de données, etc., et que vous voulez attraper l'exception, utilisez try catch finally et fermez le flux, le lecteur de données, etc. dans le finally, si vous ne le faites pas, la connexion ne sera pas fermée en cas d'erreur.

 SqlConnection myConn = new SqlConnection("Connectionstring");
        try
        {
            myConn.Open();
            //make na DB Request                
        }
        catch (Exception DBException)
        {
            //do somehting with exception
        }
        finally
        {
           myConn.Close();
           myConn.Dispose();
        }

si vous ne voulez pas attraper l'erreur, alors utilisez

 using (SqlConnection myConn = new SqlConnection("Connectionstring"))
        {
            myConn.Open();
            //make na DB Request
            myConn.Close();
        }

et l'objet de connexion sera éliminé automatiquement s'il y a une erreur, mais vous ne capturez pas l'erreur.

Answer 4

Parce que finally sera exécuté même si vous ne traitez pas une exception dans un bloc catch.

Answer 5

finally comme dans :

try {
  // do something risky
} catch (Exception ex) {
  // handle an exception
} finally {
  // do any required cleanup
}

est une opportunité garantie d'exécuter du code après que votre try..catch indépendamment du fait que votre bloc d'essai ait ou non déclenché une exception.

Cela le rend parfait pour des choses comme la libération de ressources, les connexions à des bases de données, les manipulations de fichiers, etc.