Log catturato eccezioni di fuori del metodo in cui sono stati catturati

Question

Ho un metodo simile:

public TResult DoSomethingWithLogging<TResult>(Func<TResult> someAction) 
{ 
    try 
    { 
     return someAction.Invoke(); 
    } 
    catch (Exception ex) 
    { 
     LogException(ex) 
     throw; 
    } 

Questo metodo viene utilizzato come segue:

var result = DoSomethingWithLogging(() => Foo()); 

voglio anche registrare le eccezioni che sono state catturato all'interno di Foo(). Non riesco a utilizzare throw in catch all'interno di Foo.

Come posso rilevare tali eccezioni?

Esempio:

public static string Foo() 
{ 
    try 
    { 
     return "Foo"; 
    } 
    catch (Exception) 
    { 
     // I have to log this exception too without adding anything to Foo 
     return "Exception caught";    
    }  
} 

Answer 1

È possibile eseguire il binding all'evento FirstChanceException. Ecco il tuo codice modificato per dimostrare questo:

using System; 
using System.Runtime.ExceptionServices; 

public class Program 
{ 
    public static void Main() 
    { 
     AppDomain.CurrentDomain.FirstChanceException += 
     (object source, FirstChanceExceptionEventArgs e) => 
     { 
     Console.WriteLine("FirstChanceException event raised in {0}: {1}", 
      AppDomain.CurrentDomain.FriendlyName, e.Exception.Message); 
     }; 
    Console.WriteLine("Hello World"); 
    Console.WriteLine(DoSomethingWithLogging(() => Foo())); 
    } 

    public static TResult DoSomethingWithLogging<TResult>(Func<TResult> someAction) 
    { 
    try 
    { 
     return someAction.Invoke(); 
    } 
    catch (Exception ex) 
    { 
     Console.WriteLine(ex.Message); 
     throw; 
    } 
    } 

    public static string Foo() 
    { 
    try 
    { 
     throw new Exception("This will be caught"); 
     return"Foo"; 
    } 
    catch (Exception) //I have to log this exception too without adding anything too Foo 
    { 
     return "Exception caught";  
    }  
    } 
} 

Come regola, sarei molto cauto di questo in qualcosa di diverso debug scenari. Una volta catturato, non dovrebbe essere considerato un'eccezione dal codice più in alto. (Naturalmente, coglierlo in primo luogo avrebbe potuto essere un errore logico, quindi questo ha davvero un certo valore nel debug degli scenari).

Ci sono anche complicazioni nei casi multi-thread. Il codice sopra mostra come funziona FirstChanceException, ma se è stato allegato prima della chiamata e quindi staccato dopo essere stato ancora attivato da eventuali eccezioni su altri thread. Filtrare quelli fuori potrebbe essere difficile. Probabilmente comincerei considerando di guardare lo stack delle chiamate, ma non sono sicuro che sia il modo migliore.

Answer 2

Potete farlo gestire il AppDomain.FirstChanceException event:

Si verifica quando viene generata un'eccezione nel codice gestito, prima che il runtime cerca lo stack di chiamate per un gestore di eccezioni in il dominio dell'applicazione.

Vedere Catching First Chance Exceptions in Managed Code without being debugged.

Answer 3

Penso che lo state facendo nel modo sbagliato. È una pessima idea assumere qualcosa sull'implementazione di foo. (Come JDM citato nei commenti si tratta di un odore di codice e si otterrà nei guai)

Un modo per ridisegnare il vostro approccio è quello di utilizzare gli eventi

class FooClass { 

    public event SkippedWorkEventHandler SkippedWork; 

    public void Foo() { 
     try { 
     /* some code */ 
     } catch (Exception ex) { 
     if (SkippedWork != null) { 
      /* pass in the relevant data to eventargs */ 
      SkippedWork(this, EventArgs.Empty) 
     } 
     } 
    } 

    public void DoSomethingWithFoo() { 
    SkippedWork += new LogSkippedWorkEventHandler 

    try { 
     Foo() 
    } catch (Exception ex) { 
     /*handle uncaughed exceptions here */ 
    } 

    } 
} 

La ragione di questo è che da l'i esterno non garantirò che io uso try/catch per rilevare cosa succede all'interno di foo. potrei riscriverlo a un semplice se controllo e restituire se il mio test fallisce. Il risultato di foo è lo stesso eccetto che ora le tue eccezioni non vengono registrate.

Con l'esposizione di un evento si consente a chiunque dall'esterno che è interessato a determinate cose (una linea saltata in base al commento) di reagire. e hai fatto un contratto dicendo che onorerai/innalzerai questo evento.