Come ricodificare InnerException senza perdere la traccia dello stack in C #?

Chiamo, attraverso la riflessione, un metodo che può causare un'eccezione. Come posso passare l'eccezione al mio chiamante senza che la riflessione del wrapper lo metta?
Sto ridisegnando InnerException, ma questo distrugge la traccia dello stack.
Codice di esempio:

public void test1()
{
    // Throw an exception for testing purposes
    throw new ArgumentException("test1");
}

void test2()
{
    try
    {
        MethodInfo mi = typeof(Program).GetMethod("test1");
        mi.Invoke(this, null);
    }
    catch (TargetInvocationException tiex)
    {
        // Throw the new exception
        throw tiex.InnerException;
    }
}

In .NET 4.5 ora c'è la ExceptionDispatchInfoclasse.

Ciò consente di catturare un'eccezione e rilanciarla senza modificare lo stack-trace:

try
{
    task.Wait();
}
catch(AggregateException ex)
{
    ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
}

Funziona su qualsiasi eccezione, non solo AggregateException.

È stato introdotto a causa della awaitfunzionalità del linguaggio C #, che scosta le eccezioni interne dalle AggregateExceptionistanze al fine di rendere le funzionalità del linguaggio asincrono più simili alle funzionalità del linguaggio sincrono.

Si è possibile conservare la traccia dello stack prima rethrowing senza riflessione:

static void PreserveStackTrace (Exception e)
{
    var ctx = new StreamingContext  (StreamingContextStates.CrossAppDomain) ;
    var mgr = new ObjectManager     (null, ctx) ;
    var si  = new SerializationInfo (e.GetType (), new FormatterConverter ()) ;

    e.GetObjectData    (si, ctx)  ;
    mgr.RegisterObject (e, 1, si) ; // prepare for SetObjectData
    mgr.DoFixups       ()         ; // ObjectManager calls SetObjectData

    // voila, e is unmodified save for _remoteStackTraceString
}

Questo spreca molti cicli rispetto alla chiamata InternalPreserveStackTracetramite delegato memorizzato nella cache, ma ha il vantaggio di fare affidamento solo sulla funzionalità pubblica. Ecco alcuni schemi di utilizzo comuni per le funzioni di conservazione dello stack-trace:

// usage (A): cross-thread invoke, messaging, custom task schedulers etc.
catch (Exception e)
{
    PreserveStackTrace (e) ;

    // store exception to be re-thrown later,
    // possibly in a different thread
    operationResult.Exception = e ;
}

// usage (B): after calling MethodInfo.Invoke() and the like
catch (TargetInvocationException tiex)
{
    PreserveStackTrace (tiex.InnerException) ;

    // unwrap TargetInvocationException, so that typed catch clauses 
    // in library/3rd-party code can work correctly;
    // new stack trace is appended to existing one
    throw tiex.InnerException ;
}

Penso che la tua scommessa migliore sarebbe quella di mettere questo nel tuo blocco di cattura:

throw;

E poi estrarre l'innerexception più tardi.

Nessuno ha spiegato la differenza tra ExceptionDispatchInfo.Capture( ex ).Throw()e una pianura throw, quindi eccola qui.

Il modo completo per ricodificare un'eccezione rilevata è utilizzare ExceptionDispatchInfo.Capture( ex ).Throw()(disponibile solo da .Net 4.5).

Di seguito sono riportati i casi necessari per testare questo:

1.

void CallingMethod()
{
    //try
    {
        throw new Exception( "TEST" );
    }
    //catch
    {
    //    throw;
    }
}

2.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch( Exception ex )
    {
        ExceptionDispatchInfo.Capture( ex ).Throw();
        throw; // So the compiler doesn't complain about methods which don't either return or throw.
    }
}

3.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch
    {
        throw;
    }
}

4.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch( Exception ex )
    {
        throw new Exception( "RETHROW", ex );
    }
}

Il caso 1 e il caso 2 forniscono una traccia dello stack in cui il numero di riga del codice sorgente per il CallingMethodmetodo è il numero di riga delthrow new Exception( "TEST" ) riga riga.

Tuttavia, il caso 3 fornisce una traccia dello stack in cui il numero di riga del codice sorgente per il CallingMethodmetodo è il numero di riga della throwchiamata. Ciò significa che se la throw new Exception( "TEST" )linea è circondata da altre operazioni, non si ha idea di quale numero di riga sia stata effettivamente generata l'eccezione.

Il caso 4 è simile al caso 2 perché viene conservato il numero di riga dell'eccezione originale, ma non è un vero e proprio rilancio perché modifica il tipo di eccezione originale.

public static class ExceptionHelper
{
    private static Action<Exception> _preserveInternalException;

    static ExceptionHelper()
    {
        MethodInfo preserveStackTrace = typeof( Exception ).GetMethod( "InternalPreserveStackTrace", BindingFlags.Instance | BindingFlags.NonPublic );
        _preserveInternalException = (Action<Exception>)Delegate.CreateDelegate( typeof( Action<Exception> ), preserveStackTrace );            
    }

    public static void PreserveStackTrace( this Exception ex )
    {
        _preserveInternalException( ex );
    }
}

Chiama il metodo di estensione sulla tua eccezione prima di lanciarlo, manterrà la traccia dello stack originale.

Ancora più riflessione ...

catch (TargetInvocationException tiex)
{
    // Get the _remoteStackTraceString of the Exception class
    FieldInfo remoteStackTraceString = typeof(Exception)
        .GetField("_remoteStackTraceString",
            BindingFlags.Instance | BindingFlags.NonPublic); // MS.Net

    if (remoteStackTraceString == null)
        remoteStackTraceString = typeof(Exception)
        .GetField("remote_stack_trace",
            BindingFlags.Instance | BindingFlags.NonPublic); // Mono

    // Set the InnerException._remoteStackTraceString
    // to the current InnerException.StackTrace
    remoteStackTraceString.SetValue(tiex.InnerException,
        tiex.InnerException.StackTrace + Environment.NewLine);

    // Throw the new exception
    throw tiex.InnerException;
}

Tieni presente che ciò può interrompersi in qualsiasi momento, poiché i campi privati ​​non fanno parte dell'API. Vedi ulteriori discussioni su Mono bugzilla .

Primo: non perdere TargetInvocationException - sono informazioni preziose quando vorrai eseguire il debug delle cose.
Secondo: avvolgi TIE come InnerException nel tuo tipo di eccezione e inserisci una proprietà OriginalException che si collega a ciò di cui hai bisogno (e mantieni intatto l'intero callstack).
Terzo: lascia uscire il TIE dal tuo metodo.

Ragazzi, siete forti .. Presto sarò un negromante.

    public void test1()
    {
        // Throw an exception for testing purposes
        throw new ArgumentException("test1");
    }

    void test2()
    {
            MethodInfo mi = typeof(Program).GetMethod("test1");
            ((Action)Delegate.CreateDelegate(typeof(Action), mi))();

    }

Un altro codice di esempio che utilizza la serializzazione / deserializzazione delle eccezioni. Non richiede che il tipo di eccezione effettivo sia serializzabile. Inoltre utilizza solo metodi pubblici / protetti.

    static void PreserveStackTrace(Exception e)
    {
        var ctx = new StreamingContext(StreamingContextStates.CrossAppDomain);
        var si = new SerializationInfo(typeof(Exception), new FormatterConverter());
        var ctor = typeof(Exception).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }, null);

        e.GetObjectData(si, ctx);
        ctor.Invoke(e, new object[] { si, ctx });
    }

Basato sulla risposta di Paul Turners, ho creato un metodo di estensione

    public static Exception Capture(this Exception ex)
    {
        ExceptionDispatchInfo.Capture(ex).Throw();
        return ex;
    }

l' return exIST non ha mai raggiunto, ma il vantaggio è che posso usare throw ex.Capture()come uno di linea in modo che il compilatore non genererà un not all code paths return a valueerrore.

    public static object InvokeEx(this MethodInfo method, object obj, object[] parameters)
    {
        {
            return method.Invoke(obj, parameters);
        }
        catch (TargetInvocationException ex) when (ex.InnerException != null)
        {
            throw ex.InnerException.Capture();
        }
    }