Comment renvoyer InnerException sans perdre la trace de la pile en C #?

J'appelle, par réflexion, une méthode qui peut provoquer une exception. Comment puis-je transmettre l'exception à mon appelant sans que la réflexion du wrapper ne l'entoure?
Je rejette l'InnerException, mais cela détruit la trace de la pile.
Exemple de code:

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

Dans .NET 4.5, il y a maintenant la ExceptionDispatchInfoclasse.

Cela vous permet de capturer une exception et de la renvoyer sans modifier la trace de pile:

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

Cela fonctionne sur n'importe quelle exception, pas seulement AggregateException.

Il a été introduit en raison de la awaitfonctionnalité du langage C #, qui déballe les exceptions internes des AggregateExceptioninstances afin de rendre les fonctionnalités du langage asynchrone plus semblables aux fonctionnalités du langage synchrone.

Il est possible de conserver la trace de la pile avant de relancer sans réflexion:

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
}

Cela gaspille beaucoup de cycles par rapport à un appel InternalPreserveStackTracevia un délégué mis en cache, mais a l'avantage de ne s'appuyer que sur des fonctionnalités publiques. Voici quelques modèles d'utilisation courants pour les fonctions de conservation de trace de pile:

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

Je pense que votre meilleur pari serait de simplement mettre cela dans votre bloc de capture:

throw;

Et puis extrayez plus tard l'exception interne.

Personne n'a expliqué la différence entre ExceptionDispatchInfo.Capture( ex ).Throw()et une plaine throw, alors la voici.

La manière complète de renvoyer une exception interceptée consiste à utiliser ExceptionDispatchInfo.Capture( ex ).Throw()(uniquement disponible à partir de .Net 4.5).

Vous trouverez ci-dessous les cas nécessaires pour tester cela:

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

Le cas 1 et le cas 2 vous donneront une trace de pile où le numéro de ligne de code source pour la CallingMethodméthode est le numéro de throw new Exception( "TEST" )ligne de la ligne.

Cependant, le cas 3 vous donnera une trace de pile où le numéro de ligne de code source pour la CallingMethodméthode est le numéro de ligne de l' throwappel. Cela signifie que si la throw new Exception( "TEST" )ligne est entourée d'autres opérations, vous ne savez pas à quel numéro de ligne l'exception a été levée.

Le cas 4 est similaire au cas 2 car le numéro de ligne de l'exception d'origine est conservé, mais il ne s'agit pas d'un véritable renversement car il modifie le type de l'exception d'origine.

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

Appelez la méthode d'extension sur votre exception avant de la lancer, elle conservera la trace de pile d'origine.

Encore plus de réflexion ...

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

Gardez à l'esprit que cela peut se casser à tout moment, car les champs privés ne font pas partie de l'API. Voir plus de discussion sur Mono bugzilla .

Premièrement: ne perdez pas l'exception TargetInvocationException - ce sont des informations précieuses lorsque vous voudrez déboguer des choses.
Deuxièmement: Enveloppez le TIE en tant qu'InnerException dans votre propre type d'exception et mettez une propriété OriginalException qui lie à ce dont vous avez besoin (et conservez l'intégralité de la pile d'appels intacte).
Troisièmement: laissez la bulle TIE sortir de votre méthode.

Les gars, vous êtes cool .. je vais bientôt devenir nécromancien.

    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 autre exemple de code qui utilise la sérialisation / désérialisation d'exception. Il ne nécessite pas que le type d'exception réel soit sérialisable. De plus, il utilise uniquement des méthodes publiques / protégées.

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

Sur la base de la réponse de Paul Turners, j'ai fait une méthode d'extension

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

les return ex ist n'a jamais atteint, mais l'avantage est que je peux l'utiliser throw ex.Capture()comme une ligne pour que le compilateur ne génère pas d' not all code paths return a valueerreur.

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