Wie kann ich InnerException erneut auslösen, ohne die Stapelverfolgung in C # zu verlieren?

Ich rufe durch Reflexion eine Methode auf, die eine Ausnahme verursachen kann. Wie kann ich die Ausnahme an meinen Anrufer weitergeben, ohne dass die Wrapper-Reflexion sie umgibt?
Ich werfe die InnerException erneut, aber dies zerstört die Stapelverfolgung.
Beispielcode:

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 gibt es jetzt die ExceptionDispatchInfoKlasse.

Auf diese Weise können Sie eine Ausnahme erfassen und erneut auslösen, ohne die Stapelverfolgung zu ändern:

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

Dies funktioniert mit jeder Ausnahme, nicht nur AggregateException.

Es wurde aufgrund der awaitC # -Sprachenfunktion eingeführt, die die inneren Ausnahmen von AggregateExceptionInstanzen auspackt , um die asynchronen Sprachfunktionen den synchronen Sprachfunktionen ähnlicher zu machen.

Es ist möglich, die Stapelspur vor dem erneuten Werfen ohne Reflexion beizubehalten:

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
}

Dies verschwendet viele Zyklen im Vergleich zum Aufrufen InternalPreserveStackTraceüber einen zwischengespeicherten Delegaten, hat jedoch den Vorteil, dass nur öffentliche Funktionen verwendet werden. Hier sind einige gängige Verwendungsmuster für Stack-Trace-Erhaltungsfunktionen:

// 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 ;
}

Ich denke, Ihre beste Wette wäre, dies einfach in Ihren Fangblock zu legen:

throw;

Und extrahieren Sie später die innere Ausnahme.

Niemand hat den Unterschied zwischen ExceptionDispatchInfo.Capture( ex ).Throw()und einer Ebene erklärtthrow , also hier ist es.

Der vollständige Weg, um eine abgefangene Ausnahme erneut auszulösen, ist die Verwendung ExceptionDispatchInfo.Capture( ex ).Throw() (nur ab .NET 4.5 verfügbar).

Nachfolgend sind die Fälle aufgeführt, die zum Testen erforderlich sind:

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 );
    }
}

Fall 1 und Fall 2 geben Ihnen eine Stapelverfolgung, wobei die Quellcode-Zeilennummer für die CallingMethodMethode die Zeilennummer der istthrow new Exception( "TEST" ) Zeile ist.

In Fall 3 erhalten Sie jedoch eine Stapelverfolgung, bei der die Quellcode-Zeilennummer für die CallingMethodMethode die Zeilennummer des throwAufrufs ist. Dies bedeutet, dass throw new Exception( "TEST" )Sie keine Ahnung haben, bei welcher Zeilennummer die Ausnahme tatsächlich ausgelöst wurde , wenn die Zeile von anderen Operationen umgeben ist.

Fall 4 ist ähnlich wie Fall 2, da die Zeilennummer der ursprünglichen Ausnahme beibehalten wird, jedoch kein echter Neuauswurf ist, da der Typ der ursprünglichen Ausnahme geändert wird.

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 );
    }
}

Rufen Sie die Erweiterungsmethode für Ihre Ausnahme auf, bevor Sie sie auslösen. Dadurch bleibt die ursprüngliche Stapelverfolgung erhalten.

Noch mehr Reflexion ...

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;
}

Beachten Sie, dass dies jederzeit unterbrochen werden kann, da private Felder nicht Teil der API sind. Weitere Diskussion zu Mono Bugzilla .

Erstens: Verlieren Sie nicht die TargetInvocationException - es sind wertvolle Informationen, wenn Sie Dinge debuggen möchten.
Zweitens: Wickeln Sie die TIE als InnerException in Ihren eigenen Ausnahmetyp ein und fügen Sie eine OriginalException-Eigenschaft ein, die mit dem verknüpft ist, was Sie benötigen (und den gesamten Callstack intakt halten).
Drittens: Lassen Sie die KRAWATTE aus Ihrer Methode heraussprudeln.

Leute, ihr seid cool. Ich werde bald ein Nekromant sein.

    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))();

    }

Ein weiterer Beispielcode, der die Serialisierung / Deserialisierung von Ausnahmen verwendet. Der tatsächliche Ausnahmetyp muss nicht serialisierbar sein. Außerdem werden nur öffentliche / geschützte Methoden verwendet.

    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 });
    }

Basierend auf der Antwort von Paul Turners habe ich eine Erweiterungsmethode erstellt

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

Das return exist nie erreicht, aber der Vorteil ist, dass ich es throw ex.Capture()als Einzeiler verwenden kann, damit der Compiler keinen not all code paths return a valueFehler auslöst.

    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();
        }
    }