¿Cómo volver a lanzar InnerException sin perder el seguimiento de la pila en C #?

Estoy llamando, a través de la reflexión, un método que puede causar una excepción. ¿Cómo puedo pasar la excepción a mi interlocutor sin que el reflejo del contenedor lo coloque?
Estoy volviendo a lanzar la InnerException, pero esto destruye la traza de la pila.
Código de ejemplo:

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

En .NET 4.5 ahora existe la ExceptionDispatchInfoclase.

Esto le permite capturar una excepción y volver a lanzarla sin cambiar el seguimiento de la pila:

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

Esto funciona en cualquier excepción, no solo AggregateException.

Se introdujo debido a la awaitfunción de lenguaje C #, que desenvuelve las excepciones internas de las AggregateExceptioninstancias para hacer que las funciones de lenguaje asíncrono se parezcan más a las funciones de lenguaje síncrono.

Que es posible preservar el seguimiento de la pila antes de Regeneración de sin reflexión:

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
}

Esto desperdicia muchos ciclos en comparación con las llamadas a InternalPreserveStackTracetravés de un delegado en caché, pero tiene la ventaja de depender solo de la funcionalidad pública. Aquí hay un par de patrones de uso comunes para las funciones de preservación de seguimiento de pila:

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

Creo que su mejor apuesta sería simplemente poner esto en su bloque de captura:

throw;

Y luego extraiga la innerexcepción más tarde.

Nadie ha explicado la diferencia entre ExceptionDispatchInfo.Capture( ex ).Throw()y una simple throw, así que aquí está.

La forma completa de volver a generar una excepción detectada es utilizarla ExceptionDispatchInfo.Capture( ex ).Throw()(solo disponible en .Net 4.5).

A continuación están los casos necesarios para probar esto:

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

El caso 1 y el caso 2 le darán un seguimiento de la pila donde el número de línea del código fuente para el CallingMethodmétodo es el número de línea delthrow new Exception( "TEST" ) línea línea.

Sin embargo, el caso 3 le dará un seguimiento de la pila donde el número de línea del código fuente para el CallingMethodmétodo es el número de línea de la throwllamada. Esto significa que si la throw new Exception( "TEST" )línea está rodeada por otras operaciones, no tiene idea de en qué número de línea se produjo la excepción.

El caso 4 es similar con el caso 2 porque el número de línea de la excepción original se conserva, pero no es un cambio real porque cambia el tipo de la excepción original.

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

Llame al método de extensión en su excepción antes de lanzarlo, conservará el seguimiento de la pila original.

Aún más reflexión ...

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

Tenga en cuenta que esto puede romperse en cualquier momento, ya que los campos privados no son parte de la API. Ver más discusión sobre Mono bugzilla .

Primero: no pierda la TargetInvocationException: es información valiosa cuando querrá depurar cosas.
Segundo: Envuelva el TIE como InnerException en su propio tipo de excepción y coloque una propiedad OriginalException que se vincule a lo que necesita (y mantenga intacta toda la pila de llamadas).
Tercero: deje que el TIE salga de su método.

Chicos, ustedes son geniales ... pronto seré nigromante.

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

    }

Otro código de muestra que utiliza serialización / deserialización de excepción. No requiere que el tipo de excepción real sea serializable. También utiliza solo métodos públicos / protegidos.

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

Basado en la respuesta de Paul Turners, hice un método de extensión

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

return exnunca se llegó a la meta, pero la ventaja es que puedo usarlo throw ex.Capture()como un trazador de líneas para que el compilador no genere un not all code paths return a valueerror.

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