Bagaimana cara rethrow InnerException tanpa kehilangan jejak stack di C #?

Saya memanggil, melalui refleksi, metode yang dapat menyebabkan pengecualian. Bagaimana saya bisa meneruskan pengecualian ke pemanggil saya tanpa refleksi pembungkus meletakkan di sekitarnya?
Saya memikirkan kembali InnerException, tetapi ini menghancurkan jejak stack.
Kode contoh:

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

Di .NET 4.5 sekarang ada ExceptionDispatchInfokelasnya.

Ini memungkinkan Anda menangkap pengecualian dan melemparkannya kembali tanpa mengubah tumpukan-jejak:

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

Ini bekerja dengan pengecualian apa pun, bukan hanya AggregateException.

Itu diperkenalkan karena awaitfitur bahasa C #, yang membuka bungkus pengecualian dalam AggregateExceptioninstance untuk membuat fitur bahasa asinkron lebih seperti fitur bahasa sinkron.

Hal ini dimungkinkan untuk melestarikan jejak stack sebelum rethrowing tanpa refleksi:

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
}

Ini menghabiskan banyak siklus dibandingkan dengan menelepon InternalPreserveStackTracemelalui delegasi yang di-cache, tetapi memiliki keuntungan hanya mengandalkan fungsi publik. Berikut adalah beberapa pola penggunaan umum untuk fungsi pelestarian tumpukan-jejak:

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

Saya pikir taruhan terbaik Anda adalah dengan meletakkan ini di blok tangkapan Anda:

throw;

Dan kemudian ekstrak innerexception nanti.

Tidak ada yang menjelaskan perbedaan antara ExceptionDispatchInfo.Capture( ex ).Throw()dan dataran throw, jadi ini dia.

Cara lengkap untuk mengubah kembali pengecualian yang tertangkap adalah menggunakan ExceptionDispatchInfo.Capture( ex ).Throw()(hanya tersedia dari .Net 4.5).

Di bawah ini ada kasus yang diperlukan untuk menguji ini:

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

Kasus 1 dan kasus 2 akan memberi Anda jejak tumpukan di mana nomor baris kode sumber untuk CallingMethodmetode ini adalah nomor baris dari throw new Exception( "TEST" )baris tersebut.

Namun, kasus 3 akan memberi Anda jejak tumpukan di mana nomor baris kode sumber untuk CallingMethodmetode ini adalah nomor baris throwpanggilan. Ini berarti bahwa jika throw new Exception( "TEST" )garis dikelilingi oleh operasi lain, Anda tidak tahu di mana nomor garis pengecualian itu sebenarnya dilemparkan.

Kasus 4 mirip dengan kasus 2 karena nomor baris pengecualian asli dipertahankan, tetapi bukan rethrow nyata karena mengubah jenis pengecualian asli.

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

Panggil metode ekstensi pada pengecualian Anda sebelum Anda melemparkannya, itu akan mempertahankan jejak tumpukan asli.

Bahkan lebih banyak refleksi ...

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

Ingatlah bahwa ini dapat pecah kapan saja, karena bidang pribadi bukan bagian dari API. Lihat diskusi lebih lanjut tentang Mono bugzilla .

Pertama: jangan kehilangan TargetInvocationException - ini informasi berharga ketika Anda ingin men-debug sesuatu.
Kedua: Bungkus TIE sebagai InnerException dalam tipe pengecualian Anda sendiri dan letakkan properti OriginalException yang menautkan ke apa yang Anda butuhkan (dan pertahankan seluruh panggilan tetap utuh).
Ketiga: Biarkan gelembung TIE keluar dari metode Anda.

Kawan, kau keren .. Aku akan segera menjadi ahli nujum.

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

    }

Kode contoh lain yang menggunakan serialisasi / deserialisasi pengecualian. Itu tidak memerlukan jenis pengecualian aktual menjadi serializable. Juga hanya menggunakan metode publik / dilindungi.

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

Berdasarkan jawaban Paul Turners saya membuat metode ekstensi

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

yang return exist tidak pernah mencapai tapi keuntungan adalah bahwa saya dapat menggunakan throw ex.Capture()sebagai salah satu kapal sehingga compiler tidak akan menaikkan not all code paths return a valuekesalahan.

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