Come determinare se viene gestita un'eccezione .NET?

Question

Stiamo studiando un modello di codifica in C# in cui vorremmo usare una clausola "using" con una classe speciale, il cui metodo Dispose() fa cose diverse a seconda che il corpo "using" sia stato chiuso normalmente o con un'eccezione .

Per quanto mi riguarda, il CLR tiene traccia dell'eccezione corrente gestita fino a quando non viene utilizzata da un gestore "catch". Tuttavia non è del tutto chiaro se queste informazioni sono esposte in alcun modo per il codice di accesso. Sai se lo è, e se sì, come accedervi?

Ad esempio:

using (var x = new MyObject()) 
{ 
    x.DoSomething(); 
    x.DoMoreThings(); 
} 

class MyObject : IDisposable 
{ 
    public void Dispose() 
    { 
     if (ExceptionIsBeingHandled) 
      Rollback(); 
     else 
      Commit(); 
    } 
} 

Questo sembra quasi System.Transactions.TransactionScope, tranne che il successo/insuccesso non è determinato da una chiamata a x.Complete(), ma piuttosto sulla base se il corpo using è stata chiusa normalmente.

Answer 1

http://www.codewrecks.com/blog/index.php/2008/07/25/detecting-if-finally-block-is-executing-for-an-manhandled-exception/ descrive un "trucco" per rilevare se il codice viene eseguito in modalità di gestione delle eccezioni o meno. Utilizza Marshal.GetExceptionPointers per verificare se un'eccezione è "attiva".

Ma tenere a mente:

Annotazioni

GetExceptionPointers è esposto per il supporto del compilatore di gestire unica eccezione strutturata (SEH). NotaNota:

Questo metodo utilizza SecurityAction.LinkDemand per impedire che venga chiamato da codice non attendibile; solo il chiamante immediato deve disporre dell'autorizzazione SecurityPermissionAttribute.UnmanagedCode. Se il codice può essere chiamato da codice parzialmente attendibile, non passare l'input dell'utente ai metodi della classe Marshal senza convalida. Per limitazioni importanti sull'utilizzo del membro LinkDemand, vedere Demand vs. LinkDemand.

Answer 2

Un'istruzione using è solo zucchero sintattico per un blocco try finally. È possibile ottenere ciò che si vuole scrivendo il tentativo finalmente fuori in pieno e poi l'aggiunta di un'istruzione catch per gestire il vostro caso particolare:

try 
{ 
    IDisposable x = new MyThing(); 
} 
catch (Exception exception) // Use a more specific exception if possible. 
{ 
    x.ErrorOccurred = true; // You could even pass a reference to the exception if you wish. 
    throw; 
} 
finally 
{ 
    x.Dispose(); 
} 

All'interno MyThing si può fare questo se si vuole, ad esempio:

class MyThing : IDisposable 
{ 
    public bool ErrorOccurred() { get; set; } 

    public void Dispose() 
    { 
     if (ErrorOccurred) { 
      RollBack(); 
     } else { 
      Commit(); 
     } 
    } 
} 

Nota: devo anche chiedermi perché vuoi farlo. Ha un certo odore di codice. Il metodo Dispose è destinato a ripulire le risorse non gestite, non a gestire le eccezioni. Probabilmente starai meglio scrivendo il codice di gestione delle eccezioni nel blocco catch, non nel dispose e, se hai bisogno di condividere il codice, fai alcune utili funzioni di aiuto che puoi chiamare da entrambi i posti.

Ecco un modo migliore di fare ciò che si vuole:

using (IDisposable x = new MyThing()) 
{ 
    x.Foo(); 
    x.Bar(); 
    x.CommitChanges(); 
} 

class MyThing : IDisposable 
{ 
    public bool IsCommitted { get; private set; } 

    public void CommitChanges() 
    { 
     // Do stuff needed to commit. 
     IsCommitted = true; 
    } 

    public void Dispose() 
    { 
     if (!IsCommitted) 
      RollBack(); 
    } 
} 

Answer 3

Queste informazioni non sono disponibili.

Vorrei utilizzare un modello simile a quello utilizzato dalla classe DbTransaction: ovvero, la classe IDisposable deve implementare un metodo analogo a DbTransaction.Commit(). Il metodo Dispose può quindi eseguire una logica diversa a seconda che sia stato richiamato o meno il commit (nel caso di DbTransaction, la transazione verrà annullata se non è stata stabilita esplicitamente).

Gli utenti della vostra classe sarebbero quindi utilizzare il seguente modello, simile ad un tipico DbTransaction:

using(MyDisposableClass instance = ...) 
{ 
    ... do whatever ... 

    instance.Commit(); 
} // Dispose logic depends on whether or not Commit was called. 

EDIT Vedo che hai modificato la tua domanda per mostrare che sei a conoscenza di questo modello (la tua esempio utilizza TransactionScope). Tuttavia penso che sia l'unica soluzione realistica.

Answer 4

Questa non sembra essere una cattiva idea; semplicemente non sembra essere l'ideale in C# /. NET.

In C++ è presente una funzione che consente al codice di rilevare se è stato chiamato a causa di un'eccezione. Questo è di grande importanza nei distruttori RAII; è una cosa banale per il distruttore scegliere di commettere o interrompere a seconda che il flusso di controllo sia normale o eccezionale. Penso che sia un approccio abbastanza naturale da prendere, ma la mancanza di supporto integrato (e la natura moralmente dubbia della soluzione alternativa, mi sembra piuttosto dipendente dall'implementazione) probabilmente significa che dovrebbe essere adottato un approccio più convenzionale.

Answer 5

Non una risposta alla domanda, ma solo una nota che non ho mai finito con l'hack "accettato" nel codice reale, quindi è ancora ampiamente testato "in the wild". Invece siamo andati per qualcosa di simile:

DoThings(x => 
{ 
    x.DoSomething(); 
    x.DoMoreThings(); 
}); 

dove

public void DoThings(Action<MyObject> action) 
{ 
    bool success = false; 
    try 
    { 
     action(new MyObject()); 
     Commit(); 
     success = true; 
    } 
    finally 
    { 
     if (!success) 
      Rollback(); 
    } 
} 

Il punto chiave è che è compatto come il "utilizzando" ad esempio nella questione, e non utilizza alcun hack.

Tra gli inconvenienti vi è una penalità di prestazioni (completamente trascurabile nel nostro caso) e F10 che entra nello DoThings quando in realtà lo desidero semplicemente passare direttamente a x.DoSomething(). Entrambi molto minori.