C＃でスタックトレースを失わずにInnerExceptionを再スローする方法は？

リフレクションを介して、例外を引き起こす可能性のあるメソッドを呼び出しています。ラッパーリフレクションが例外を配置せずに例外を呼び出し元に渡すにはどうすればよいですか？
InnerExceptionを再スローしていますが、これによりスタックトレースが破壊されます。
コード例：

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

では、.NET 4.5今そこにあるExceptionDispatchInfoクラス。

これにより、スタックトレースを変更せずに例外をキャプチャして再スローできます。

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

これは、だけでなく、すべての例外で機能しますAggregateException。

これは、非同期言語機能を同期言語機能のようにするためにawait、AggregateExceptionインスタンスからの内部例外をアンラップするC＃言語機能により導入されました。

リフレクションなしで再スローする前にスタックトレースを保持することが可能です。

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
}

これInternalPreserveStackTraceは、キャッシュされたデリゲート経由の呼び出しに比べて多くのサイクルを無駄にしますが、パブリック機能のみに依存するという利点があります。スタックトレース保持機能の一般的な使用パターンをいくつか次に示します。

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

私はあなたの最善の策はこれをあなたのキャッチブロックに入れることだと思います：

throw;

そして、後でinnerexceptionを抽出します。

ExceptionDispatchInfo.Capture( ex ).Throw()とプレーンの違いを説明した人はいませんthrow。

キャッチされた例外を再スローする完全な方法は、使用することですExceptionDispatchInfo.Capture( ex ).Throw()（.Net 4.5からのみ利用可能）。

以下に、これをテストするために必要なケースがあります。

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

ケース1とケース2は、CallingMethodメソッドのソースコード行番号が行の行番号であるスタックトレースを提供しますthrow new Exception( "TEST" )。

ただし、ケース3では、CallingMethodメソッドのソースコード行番号がthrow呼び出しの行番号であるスタックトレースが得られます。これは、throw new Exception( "TEST" )行が他の操作に囲まれている場合、例外が実際にスローされた行番号がわからないことを意味します。

ケース4は、元の例外の行番号が保持されるという点でケース2と似ていますが、元の例外のタイプを変更するため、実際の再スローではありません。

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

例外をスローする前に、拡張メソッドを呼び出して、元のスタックトレースを保持します。

さらに反射...

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

非公開フィールドはAPIの一部ではないため、これはいつでも壊れる可能性があることに注意してください。Mono bugzillaに関する詳細な議論をご覧ください。

まず、TargetInvocationExceptionを失わないようにしてください。デバッグするときに役立つ情報です。
次に、TIEを独自の例外タイプのInnerExceptionとしてラップし、必要なものにリンクするOriginalExceptionプロパティを配置します（コールスタック全体をそのままにします）。
3番目：メソッドからTIEをバブルアウトします。

みんな、かっこいい..すぐにネクロマンサーになる。

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

    }

例外のシリアル化/逆シリアル化を使用する別のサンプルコード。実際の例外タイプをシリアライズ可能にする必要はありません。また、パブリック/保護されたメソッドのみを使用します。

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

ポールターナーズの回答に基づいて、拡張メソッドを作成しました

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

これはreturn ex決して到達しませんが、利点はthrow ex.Capture()、コンパイラーがnot all code paths return a valueエラーを発生させないように、1つのライナーとして使用できることです。

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