Utilizzando infine, invece di cattura

Question

Ho visto questo modello un paio di volte:

 bool success = false; 
     try 
     { 
      DoSomething(); 
      success = true; 
     } 
     finally 
     { 
      if (!success) 
       Rollback(); 
     } 

E mi sono chiesto: perché questo è meglio che usare delle catture di rollback?

 try 
     { 
      DoSomething(); 
     } 
     catch 
     { 
      Rollback(); 
      throw; 
     } 

Quali sono le differenze tra i due modi per assicurarsi che le modifiche vengano ripristinate in caso di errore?

Answer 1

L'obiettivo chiaro qui è di chiamare Rollback in caso di errore. Entrambi i frammenti di codice raggiungono questo obiettivo. Il primo utilizza infine, che esegue sempre, che verifica che l'ultima riga del blocco try sia stata raggiunta correttamente. Il secondo rileva eventuali errori, ripristina la transazione e quindi rigenera l'eccezione che è stata rilevata. Il risultato di uno snippet è che eventuali eccezioni generate comporteranno un rollback mentre continuano a tornare al livello successivo.

Hai detto che il progetto è stato convertito da Java. In Java, è possibile re-throw an exception in modo simile a come è possibile in C# utilizzando throw;. Puoi anche throw a new exception che manterrà comunque lo stack di chiamate (et al). Il secondo è un po 'più chiaro/semplice in C# (non molto però) e il primo ha il vantaggio di lavorare effettivamente in Java come scritto.

Answer 2

finally viene sempre eseguito, non solo per rilevare eccezioni.

scontato, in questo specifico caso il rollback è necessaria solo quando c'è stato un errore, ma come un modello generale, il try-finally può essere più utile per la gestione delle risorse (dove spesso è necessario assicurarsi che avete sempre Close() o Dispose() di la tua risorsa correttamente). Soprattutto se l'autore del codice proviene da uno sfondo Java in cui questo idioma è più diffuso.

Answer 3

L'istruzione finally viene in genere utilizzata per la pulizia delle risorse. Il metodo Rollback() potrebbe essere utilizzabile lì se le eccezioni non sono gli unici motivi per ripristinare la transazione. I metodi Close() o Dispose() sono i primi candidati a finire nel blocco finale.

Tuttavia, non si desidera eseguire nulla che possa generare eccezioni.

Answer 4

Inserisco qui del codice anche se non è realmente correlato alla domanda (verrà eliminato in seguito).

Con questo programma:

using System; 

namespace testcs 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      try 
      { 
       try 
       { 
        foo(); 
        foo(); 
        foo(); 
       } 
       catch 
       { 
        throw; 
       } 
      } 
      catch (Exception e) 
      { 
       Console.WriteLine(e.ToString()); 
      } 
     } 

     private static void foo() 
     { 
      throw new Exception("oops"); 
     } 
    } 
} 

L'analisi dello stack (! Guardare i numeri di riga) è conservato, ma all'interno della funzione main vedrete "linea 19", la linea dove throw è invece il vero riga dove è stato chiamato foo() (riga 13).

Answer 5

io non sono sicuro se questo non è solo anecdotal evidence, ma io personalmente ho usato questo modello per un motivo molto pratico: Quando DoSomething genera un'eccezione, il debugger di Visual Studio si romperà in DoSomething in cui si verifica l'eccezione nella prima versione, mentre si romperà allo throw; nella seconda versione. Ciò consente di ispezionare lo stato dell'applicazione prima che Rollback abbia eliminato tutto.

Answer 6

Se non si cura in questo particolare codice di ciò che tipo di eccezione si stanno recuperando l'uso:

try 
{ 
    DoSomething(); 
    ok = true; 
} 
finally 
{ 
    if(!ok)Rollback(); 
} 

Ciò manterrà Stack di chiamate nella sua forma originale per il 100%. Anche se si utilizza eccezione maching come questo:

try 
{ 
    DoSomething(); 
    ok = true; 
} 
catch(FirstExcetionType e1) 
{ 
    //do something 
} 
catch(SecondExcetionType e2) 
{ 
    //do something 
} 
catch(Exception e3) 
{ 
    //do something 
} 
finally 
{ 
    if(!ok)Rollback(); 
} 

usando finalmente alla fine può rendere il codice più leggibile che chiamare rollback da ogni dichiarazione singola cattura.