सी # में, मैं स्टैक ट्रेस खोए बिना InnerException को कैसे पुनर्स्थापित कर सकता हूं?

Question

मैं प्रतिबिंब के माध्यम से फोन कर रहा हूं, एक विधि जो अपवाद का कारण बन सकती है। रैपर प्रतिबिंब के चारों ओर रखे बिना मैं अपने कॉलर को अपवाद कैसे पारित कर सकता हूं? मैं इनर एक्सेप्शन को पुनर्स्थापित कर रहा हूं, लेकिन यह स्टैक ट्रेस को नष्ट कर देता है। उदाहरण कोड:

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

में .NET 4.5 वहाँ अब ExceptionDispatchInfo वर्ग है।

यह आपको एक अपवाद को पकड़ने और यह ढेर ट्रेस बदले बिना फिर से फेंक कर सकते हैं:

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

यह किसी भी अपवाद नहीं, AggregateException पर काम करता है।

यह await सी # भाषा सुविधा के कारण पेश किया गया था, जो AggregateException उदाहरणों से आंतरिक अपवादों को अनचाहे करता है ताकि सिंक्रोनस भाषा सुविधाओं को सिंक्रोनस भाषा सुविधाओं की तरह अधिक बनाया जा सके।

Answer 2

मुझे लगता है कि आपका सर्वश्रेष्ठ दांव सिर्फ अपनी पकड़ ब्लॉक में इस डाल करने के लिए होगा:

throw; 

और फिर बाद में InnerException निकालें।

Answer 3

इससे भी अधिक प्रतिबिंब ...

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

ध्यान रखें कि यह किसी भी समय टूट सकता है, के रूप में निजी क्षेत्रों एपीआई का हिस्सा नहीं हैं। Mono bugzilla पर और चर्चा देखें।

Answer 4

पहला: लक्ष्यInvocationException को न खोएं - जब आप चीजों को डीबग करना चाहते हैं तो यह मूल्यवान जानकारी है।
दूसरा: टीआईई को अपने अपवाद प्रकार में इनर एक्सेप्शन के रूप में लपेटें और एक मूल अपवाद संपत्ति डालें जो आपको चाहिए (और पूरे कॉलस्टैक को बरकरार रखें)।
तीसरा: टीआईई बबल को अपनी विधि से बाहर जाने दें।

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

इसे फेंकने से पहले अपने अपवाद पर विस्तार विधि को कॉल करें, यह मूल स्टैक ट्रेस को संरक्षित रखेगा।

Answer 6

दोस्तों, आप शांत हैं .. मैं जल्द ही एक 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

यह प्रतिबिंब के बिना rethrowing से पहले स्टैक ट्रेस की रक्षा करने के संभव है:

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

Answer 8

Anpother नमूना कोड: यहाँ ढेर का पता लगाने के संरक्षण कार्यों के लिए आम उपयोग पैटर्न के एक जोड़े हैं। इसे वास्तविक अपवाद प्रकार को क्रमबद्ध करने की आवश्यकता नहीं है। इसके अलावा यह केवल सार्वजनिक/संरक्षित विधियों का उपयोग करता है।

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

किसी ने भी 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 के समान है क्योंकि मूल अपवाद की लाइन संख्या संरक्षित है, लेकिन वास्तविक रीथ्रो नहीं है क्योंकि यह मूल अपवाद के प्रकार को बदलती है।