Utilisez un bloc ‘try-finally’ sans bloc ‘catch’

Y a-t-il des situations où il est approprié d’utiliser un bloc try-finally sans bloc catch ?

Vous l’utiliseriez pour vous assurer que certaines actions se produisent après le contenu du test ou sur une exception, mais que vous ne souhaitez pas utiliser cette exception.

Pour être clair, cela ne cache pas les exceptions. Le bloc finally est exécuté avant que l’exception ne soit propagée dans la stack d’appels.

Vous l’utiliseriez également par inadvertance lorsque vous utilisez le mot-clé using , car cela comstack dans un try-finally (pas une conversion exacte, mais pour des raisons d’argument, il est assez proche).

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

L’exécution du code n’est pas garantie, mais le cas où il n’est pas garanti est assez avancé – je ne m’en souviens même pas. Tout ce dont je me souviens, c’est que si vous êtes dans ce cas, il est fort probable que le fait de ne pas exécuter le problème finally ne soit pas votre plus gros problème :-).

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

Mise à jour depuis Paddy: Conditions lorsque finalement, ne s’exécute pas dans un .net try..finally block

L’exemple le plus courant que vous pouvez voir est l’élimination d’une connexion de firebase database ou d’une ressource externe même si le code échoue:

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

Comstack en quelque chose comme:

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

using est équivalente à try-finally . Vous n’utiliserez try-finally lorsque vous souhaitez effectuer un nettoyage à l’intérieur et ne vous souciez pas de l’exception.

La meilleure approche sera

 try { using(resource) { //Do something here } }catch(Exception) { //Handle Error } 

Même si le nettoyage appelé à l’ using échoue, votre code n’échouera pas.

Il y a une condition quand finally ne sera pas exécuté.

  • S’il y a une StackOverflowException ou StackOverflowException .
  • Le processus est supprimé de la source externe.

J’espère que cela répond à votre doute.

Si vous avez, par exemple, une ressource non managée que vous créez et utilisez dans le bloc try, vous pouvez utiliser le bloc finally pour vous assurer que vous libérez cette ressource. Le bloc finally sera toujours exécuté malgré ce qui se passe (par exemple, les exceptions) dans le bloc try.

Par exemple, l’instruction lock (x) est vraiment:

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

Le bloc finally sera toujours appelé pour s’assurer que le verrou exclusif est libéré.

Bonne explication en utilisant le code:

 void MyMethod1() { try { MyMethod2(); MyMethod3(); } catch(Exception e) { //do something with the exception } } void MyMethod2() { try { //perform actions that need cleaning up } finally { //clean up } } void MyMethod3() { //do something } 

Si MyMethod2 ou MyMethod3 lève une exception, celle-ci sera interceptée par MyMethod1. Toutefois, le code dans MyMethod2 doit exécuter du code de nettoyage, par exemple en fermant une connexion à la firebase database, avant que l’exception ne soit transmise à MyMethod1.

http://forums.asp.net/t/1092267.aspx?Try+without+Catch+but+with+finally+doesn+t+throw+error+Why+no+syntax+error+

Vous avez besoin d’un bloc finally, peu importe quelles exceptions (le cas échéant) sont détectées ou même si aucune n’est interceptée, vous souhaitez quand même exécuter du code avant que le bloc ne se ferme. Par exemple, vous pouvez vouloir fermer un fichier ouvert.

Voir aussi try-finally

try / finally: lorsque vous ne souhaitez pas gérer les exceptions, mais que vous souhaitez vous assurer que des actions se produisent, qu’une exception soit déclenchée ou non par le code appelé.

Regardez le lien suivant: https://softwareengineering.stackexchange.com/questions/131397/why-use-try-finally-without-a-catch-clause

Cela dépend de l’architecture de votre application et de l’opération que vous effectuez dans le bloc.

Voici une situation où vous pourriez vouloir utiliser try finally: lorsque vous utiliseriez normalement une instruction using, mais que vous ne pouvez pas parce que vous appelez une méthode par reflection.

Cela ne marchera 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 = (ssortingng)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-Final, vous pourriez faire plus élégamment avec une instruction using . C ++ n’a même pas de résultat final grâce à son RAII .

Voici un cas d’utilisation que j’utilise toujours (hum ..):

 int? x; //note the nullable type here! try { x = int.Parse(someSsortingng); } catch { } //don't care, let it just be null 

1.nous pouvons utiliser le bloc try sans attraper mais nous devrions utiliser catch / finally, n’importe lequel d’entre eux. 2.Nous ne pouvons pas utiliser uniquement try block.