Làm cách nào để lấy lại InternalException mà không mất dấu vết ngăn xếp trong C #?

Tôi đang gọi, thông qua sự phản ánh, một phương pháp có thể gây ra một ngoại lệ. Làm thế nào tôi có thể chuyển ngoại lệ cho người gọi của mình mà không có sự phản chiếu của trình bao bọc xung quanh nó?
Tôi đang điều chỉnh lại InternalException, nhưng điều này sẽ phá hủy dấu vết ngăn xếp.
Mã ví dụ:

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

Trong .NET 4.5 hiện cóExceptionDispatchInfo lớp.

Điều này cho phép bạn nắm bắt một ngoại lệ và ném lại mà không thay đổi dấu vết ngăn xếp:

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

Điều này hoạt động trên bất kỳ ngoại lệ, không chỉ AggregateException .

Nó được giới thiệu do awaittính năng ngôn ngữ C #, giúp loại bỏ các ngoại lệ bên trong khỏi các AggregateExceptionphiên bản để làm cho các tính năng ngôn ngữ không đồng bộ giống với các tính năng ngôn ngữ đồng bộ hơn.

Đó là khả năng để bảo vệ vết đống trước rethrowing mà không cần suy nghĩ:

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
}

Điều này lãng phí rất nhiều chu kỳ so với việc gọi InternalPreserveStackTracequa đại biểu được lưu trong bộ nhớ cache, nhưng có lợi thế là chỉ dựa vào chức năng công cộng. Dưới đây là một vài mẫu sử dụng phổ biến cho các chức năng bảo quản theo dõi ngăn xếp:

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

Tôi nghĩ rằng đặt cược tốt nhất của bạn sẽ là chỉ đặt điều này trong khối bắt của bạn:

throw;

Và sau đó trích xuất nhận thức innerexception sau.

Không ai giải thích được sự khác biệt giữa ExceptionDispatchInfo.Capture( ex ).Throw()và đồng bằng throw, vì vậy đây là.

Cách hoàn chỉnh để lấy lại một ngoại lệ bị bắt là sử dụng ExceptionDispatchInfo.Capture( ex ).Throw()(chỉ có sẵn từ .Net 4.5).

Dưới đây là các trường hợp cần thiết để kiểm tra điều này:

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

Trường hợp 1 và trường hợp 2 sẽ cung cấp cho bạn một dấu vết ngăn xếp trong đó số dòng mã nguồn cho CallingMethodphương thức là số dòng củathrow new Exception( "TEST" ) dòng.

Tuy nhiên, trường hợp 3 sẽ cung cấp cho bạn một dấu vết ngăn xếp trong đó số dòng mã nguồn cho CallingMethodphương thức là số dòng của throwcuộc gọi. Điều này có nghĩa là nếu throw new Exception( "TEST" )dòng được bao quanh bởi các hoạt động khác, bạn không biết số dòng nào thực sự bị ném.

Trường hợp 4 tương tự với trường hợp 2 vì số dòng của ngoại lệ ban đầu được giữ nguyên, nhưng không phải là một suy nghĩ thực sự vì nó thay đổi loại ngoại lệ ban đầu.

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

Gọi phương thức mở rộng về ngoại lệ của bạn trước khi bạn ném nó, nó sẽ giữ nguyên dấu vết ngăn xếp ban đầu.

Thậm chí nhiều phản ánh ...

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

Hãy nhớ rằng điều này có thể bị hỏng bất cứ lúc nào, vì các trường riêng không phải là một phần của API. Xem thảo luận thêm về Mono bugzilla .

Đầu tiên: không mất TargetInvocationException - đó là thông tin có giá trị khi bạn muốn gỡ lỗi mọi thứ.
Thứ hai: Bao bọc TIE dưới dạng InternalException trong loại ngoại lệ của riêng bạn và đặt thuộc tính OriginalException liên kết đến những gì bạn cần (và giữ nguyên toàn bộ bảng gọi).
Thứ ba: Hãy để bong bóng TIE ra khỏi phương pháp của bạn.

Các bạn, bạn thật tuyệt .. Tôi sẽ sớm trở thành một thầy chiêu hồn.

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

    }

Mã mẫu anpother sử dụng tuần tự hóa / giải tuần tự ngoại lệ. Nó không yêu cầu loại ngoại lệ thực tế để được tuần tự hóa. Ngoài ra, nó chỉ sử dụng phương pháp công cộng / được bảo vệ.

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

Dựa trên câu trả lời của Paul Turners tôi đã thực hiện một phương pháp mở rộng

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

các return exist bao giờ đạt được nhưng lợi thế là tôi có thể sử dụng throw ex.Capture()như một lót để trình biên dịch sẽ không tăng not all code paths return a valuelỗi.

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