Como relançar InnerException sem perder o rastreamento de pilha em c #?

Estou chamando, através da reflexão, de um método que pode causar uma exceção. Como posso passar a exceção para o meu interlocutor sem que o reflexo do wrapper o rodeie?
Estou repetindo a InnerException, mas isso destrói o rastreamento de pilha.
Código de exemplo:

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

No .NET 4.5 , agora existe a ExceptionDispatchInfoclasse.

Isso permite capturar uma exceção e lançá-la novamente sem alterar o rastreamento de pilha:

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

Isso funciona em qualquer exceção, não apenas AggregateException.

Foi introduzido devido ao awaitrecurso de linguagem C #, que desvenda as exceções internas das AggregateExceptioninstâncias para tornar os recursos de linguagem assíncrona mais parecidos com os recursos de linguagem síncrona.

Ele é possível preservar o rastreamento de pilha antes rethrowing sem reflexão:

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
}

Isso desperdiça muitos ciclos em comparação com as chamadas InternalPreserveStackTracevia delegado em cache, mas tem a vantagem de depender apenas da funcionalidade pública. Aqui estão alguns padrões de uso comuns para funções de preservação de rastreamento de pilha:

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

Eu acho que sua melhor aposta seria colocar isso no seu bloco de captura:

throw;

E depois extraia a inerexceção mais tarde.

Ninguém explicou a diferença entre ExceptionDispatchInfo.Capture( ex ).Throw()e uma planície throw, então aqui está.

A maneira completa de reconfigurar uma exceção capturada é usar ExceptionDispatchInfo.Capture( ex ).Throw()(disponível apenas no .Net 4.5).

Abaixo há os casos necessários para testar isso:

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

O caso 1 e o caso 2 fornecerão um rastreamento de pilha em que o número da linha do código-fonte do CallingMethodmétodo é o número da throw new Exception( "TEST" )linha.

No entanto, o caso 3 fornecerá um rastreamento de pilha em que o número da linha do código-fonte do CallingMethodmétodo é o número da linha da throwchamada. Isso significa que, se a throw new Exception( "TEST" )linha estiver cercada por outras operações, você não terá idéia de qual número de linha a exceção foi realmente lançada.

O caso 4 é semelhante ao caso 2, porque o número da linha da exceção original é preservado, mas não é uma releitura real, pois altera o tipo da exceção 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 );
    }
}

Chame o método de extensão em sua exceção antes de executá-lo, pois ele preservará o rastreamento de pilha original.

Ainda mais reflexão ...

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

Lembre-se de que isso pode ocorrer a qualquer momento, pois os campos particulares não fazem parte da API. Veja mais discussões sobre o Mono bugzilla .

Primeiro: não perca o TargetInvocationException - são informações valiosas quando você deseja depurar as coisas.
Segundo: Embrulhe o TIE como InnerException em seu próprio tipo de exceção e coloque uma propriedade OriginalException vinculada ao que você precisa (e mantenha intacta a pilha de chamadas inteira).
Terceiro: deixe o TIE sair do seu método.

Gente, você é legal .. Eu vou ser um necromante em breve.

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

    }

Outro código de exemplo que usa serialização / desserialização de exceção. Não requer que o tipo de exceção real seja serializável. Também usa apenas 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 });
    }

Com base na resposta de Paul Turners, fiz um método de extensão

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

o return exist nunca foi alcançado, mas a vantagem é que eu posso usar throw ex.Capture()como um liner para que o compilador não apresente not all code paths return a valueerros.

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