Trong C#, làm thế nào tôi có thể tính toán lại InnerException mà không làm mất dấu vết ngăn xếp?

Question

Tôi đang gọi, thông qua sự phản chiếu, 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ể vượt qua ngoại lệ cho người gọi của tôi mà không có sự phản ánh wrapper đặt xung quanh nó? Tôi đang rethrowing InnerException, nhưng điều này phá hủy các dấu vết stack. 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; 
     } 
    } 

Answer 1

Trong .NET 4.5 hiện nay là lớp ExceptionDispatchInfo.

này cho phép bạn chụp một ngoại lệ và tái ném nó mà không thay đổi stack-trace:

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

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

Được giới thiệu do tính năng ngôn ngữ C# await C#, mở khóa các ngoại lệ bên trong từ AggregateException trường hợp để 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ộ.

Answer 2

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

throw; 

Và sau đó trích xuất các InnerException sau.

Answer 3

phản ánh Thậm chí nhiều hơ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; 
} 

Hãy ghi nhớ rằng điều này có thể phá vỡ bất cứ lúc nào, như lĩnh vực tư nhân không phải là một phần của API. Xem thêm thảo luận về Mono bugzilla.

Answer 4

Đầu tiên: không bị mất TargetInvocationException - đó là thông tin giá trị khi bạn muốn gỡ lỗi mọi thứ.
Thứ hai: Gói TIE là InnerException 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ộ callstack).
Thứ ba: Hãy để bong bóng TIE ra khỏi phương pháp của bạn.

Answer 5

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 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.

Answer 6

Các bạn, bạn thật tuyệt .. Tôi sẽ sớm trở thành một necromancer.

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

    } 

Answer 7

Nó là có thể để 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 
} 

này lãng phí rất nhiều chu kỳ so với gọi InternalPreserveStackTrace qua đại biểu lưu trữ, nhưng có lợi thế là chỉ dựa về 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 ngăn xếp dấu vết:

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

Answer 8

Mã mẫu khác sử dụng tuần tự/deserialization ngoại lệ. Nó không yêu cầu loại ngoại lệ thực tế được serializable. Ngoài ra, nó chỉ sử dụng các phương thức 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 }); 
    } 

Answer 9

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

Cách hoàn chỉnh để tính lại ngoại lệ bị bắt là sử dụng ExceptionDispatchInfo.Capture(ex).Throw() (chỉ khả dụng từ .Net 4.5).

Dưới đây có những 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 theo dõi ngăn xếp nơi số dòng mã nguồn cho phương pháp CallingMethod là số dòng của dòng throw new Exception("TEST").

Tuy nhiên, trường hợp 3 sẽ cung cấp cho bạn theo dõi ngăn xếp nơi số dòng mã nguồn cho phương thức CallingMethod là số dòng của cuộc gọi throw. Điều này có nghĩa rằng nếu đường dây throw new Exception("TEST") được bao quanh bởi các hoạt động khác, bạn không có ý tưởng về số dòng mà ngoại lệ đã thực sự được 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 thực tế rethrow vì nó thay đổi loại ngoại lệ ban đầu.