L'utilisation d'un try-finally "en bloc sans un "catch" bloc

Vous pouvez l'utiliser pour faire en sorte que certaines actions se produisent après la try contenu ou sur une exception, mais quand vous ne souhaitez pas consommer qu'une exception.

Juste pour être clair, cela ne cache pas les exceptions. Le finally bloc est exécuté avant que l'exception est propagée haut de la pile des appels.

Vous pouvez aussi les utiliser par inadvertance lorsque vous utilisez le using mot-clé, parce que cette compile dans un try-finally (pas de convertir, mais pour la commodité du raisonnement, il est assez proche).

try
{
    TrySomeCodeThatMightException();
}
finally
{
    CleanupEvenOnFailure();
}

Code qui s'exécute dans finally n'est pas garanti, cependant le cas où il n'est pas garanti, c'est assez de bord, je ne peux même pas vous en rappeler. Ce dont je me souviens est, si vous êtes dans ce cas, les chances sont très bonnes que de ne pas courir le finally n'est pas votre plus gros problème 🙂 donc, fondamentalement, ne vous en faites pas.

Mise à jour de Tobias: finally ne sera pas exécuté si le processus est tué.

Mise à jour à partir du riz Paddy: Conditions quand, finalement, ne s'exécute pas dans un .net try..finally bloc

La plus répandue est l'exemple que vous pouvez voir est de disposer d'une connexion de base de données ou de ressources externes, même si le code ne fonctionne pas:

using (var conn = new SqlConnection("")) //Ignore the fact we likely use ORM ;-)
{
    //Do stuff.
}

Compile en quelque chose comme:

SqlConnection conn;

try
{
    conn = new SqlConnection("");
    //Do stuff.
}
finally
{
    if (conn != null)
        conn.Dispose();
}

Si vous avez, par exemple, une ressource non managée de créer et d'utiliser dans le bloc try, vous pouvez utiliser le bloc finally pour vous assurer de la libération de la ressource. Le bloc finally est toujours exécuté en dépit de ce qui se passe (par exemple, les exceptions) dans le bloc try.

E. g. le verrou(x) déclaration est vraiment:

System.Threading.Monitor.Enter(x); 
try { ... } 
finally 
{ 
    System.Threading.Monitor.Exit(x); 
} 

Le bloc finally est toujours appelée à s'assurer que le verrou exclusif est libéré.

Vous avez besoin d'un bloc finally, lorsque n'importe qui (le cas échéant) les exceptions sont capturés ou même si aucun n'est pris, vous voulez toujours exécuter du code avant de le bloquer les sorties. Par exemple, vous pouvez fermer et ouvrir un fichier.

Voir Aussi try-finally

Voici une situation où vous pourriez vouloir essayer enfin: lorsque vous utilisez normalement à l'aide d'instruction, mais ne peut pas parce que vous êtes à l'appel d'une méthode par réflexion.

Cela ne fonctionne pas

using (objMsg  =  Activator.CreateInstance(TypeAssist.GetTypeFromTypeName("omApp.MessagingBO")))
{

}

au lieu d'utiliser

           object objMsg = null;
            try
            {
                objMsg
                   = Activator.CreateInstance(TypeAssist.GetTypeFromTypeName("myAssembly.objBO"));

                strResponse = (string)objMsg.GetType().InvokeMember("MyMethod", BindingFlags.Public
                        | BindingFlags.Instance | BindingFlags.InvokeMethod, null, objMsg,
                        new object[] { vxmlRequest.OuterXml });
            }               
            finally
            {
                if (objMsg!=null)
                    ((IDisposable)objMsg).Dispose();
            }

Je ne sais rien à propos de C#, mais il semble que tout ce que vous pourriez faire avec un try-finally, vous pourriez plus élégamment faire avec un instruction d'utilisation. C++ n'ont même pas enfin que à la suite de son RAII.

1.nous pouvons utiliser le bloc try sans attraper, mais nous devrions utiliser le catch/finally,
l'un d'eux.
2.Nous ne pouvons pas utiliser uniquement le bloc de l'essai.