थोड़ी देर के लूप का उपयोग किए बिना आंतरिक-सबसे अपवाद का पता लगाएं?

Question 1

जब C # एक अपवाद फेंकता है, तो इसका एक आंतरिक अपवाद हो सकता है। मैं जो करना चाहता हूं उसे आंतरिक-सबसे अधिक अपवाद मिलता है, या दूसरे शब्दों में, पत्ती अपवाद जिसमें आंतरिक अपवाद नहीं है। मैं थोड़ी देर में यह कर सकता हूं:

while (e.InnerException != null)
{
    e = e.InnerException;
}

लेकिन मैं सोच रहा था कि क्या कोई एक-लाइनर था जिसका उपयोग मैं इसके बजाय कर सकता था।

Question 2

एक लाइन :)

while (e.InnerException != null) e = e.InnerException;

जाहिर है, आप इसे कोई सरल नहीं बना सकते।

जैसा कि ग्लेन मैक्लेहो द्वारा इस उत्तर में कहा गया है , यह एकमात्र विश्वसनीय तरीका है।

Question 3

मेरा मानना Exception.GetBaseException()है कि इन समाधानों के रूप में एक ही बात करता है।

कैविएट: विभिन्न टिप्पणियों से हमें पता चला है कि यह हमेशा एक ही काम नहीं करता है, और कुछ मामलों में पुनरावर्ती / पुनरावृत्ति समाधान आपको आगे मिलेगा। यह आमतौर पर अंतरतम अपवाद है, जो निराशाजनक रूप से असंगत है, कुछ प्रकार के अपवादों के लिए धन्यवाद जो डिफ़ॉल्ट को ओवरराइड करता है। हालाँकि यदि आप विशिष्ट प्रकार के अपवादों को पकड़ते हैं और यह सुनिश्चित करते हैं कि वे ऑडबॉल (जैसे एग्रीगेटएक्स अपवाद) नहीं हैं, तो मुझे उम्मीद है कि इसे वैध अंतरतम / जल्द से जल्द अपवाद मिलेगा।

Question 4

इनर एक्सेप्शन के माध्यम से लूपिंग एकमात्र विश्वसनीय तरीका है।

यदि पकड़ा गया अपवाद एक AggregateException है, तो GetBaseException()केवल सबसे अलग AggregateException देता है।

http://msdn.microsoft.com/en-us/library/system.aggregateexception.getbaseexception.aspx

Question 5

यदि आप नहीं जानते कि आंतरिक अपवाद कितने गहरे हैं, तो पाश या पुनरावृत्ति के आसपास कोई रास्ता नहीं है।

बेशक, आप एक विस्तार विधि को परिभाषित कर सकते हैं जो इसे दूर करती है:

public static class ExceptionExtensions
{
    public static Exception GetInnermostException(this Exception e)
    {
        if (e == null)
        {
            throw new ArgumentNullException("e");
        }

        while (e.InnerException != null)
        {
            e = e.InnerException;
        }

        return e;
    }
}

Question 6

मुझे पता है कि यह एक पुरानी पोस्ट है, लेकिन मुझे आश्चर्य है कि किसी ने भी यह सुझाव नहीं दिया GetBaseException()कि यह Exceptionकक्षा में एक विधि है :

catch (Exception x)
{
    var baseException = x.GetBaseException();
}

यह .NET 1.1 के बाद से आसपास है। यहाँ प्रलेखन: http://msdn.microsoft.com/en-us/library/system.exception.getbaseexception(v=vs.71).aspx

Question 7

कभी-कभी आपके पास कई आंतरिक अपवाद हो सकते हैं (कई बुदबुदाने वाले अपवाद)। जिस स्थिति में आप करना चाहते हैं:

List<Exception> es = new List<Exception>();
while(e.InnerException != null)
{
   es.add(e.InnerException);
   e = e.InnerException
}

Question 8

काफी एक लाइन नहीं, लेकिन करीब:

        Func<Exception, Exception> last = null;
        last = e => e.InnerException == null ? e : last(e.InnerException);

Question 9

वास्तव में इतना आसान है, आप उपयोग कर सकते हैं Exception.GetBaseException()

Try
      //Your code
Catch ex As Exception
      MessageBox.Show(ex.GetBaseException().Message, My.Settings.MsgBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
End Try

Question 10

आपको लूप करना है, और लूप में होना है, लूप को एक अलग फ़ंक्शन में स्थानांतरित करने के लिए क्लीनर है।

मैंने इससे निपटने के लिए एक विस्तार विधि बनाई। यह अपवाद का पीछा करते हुए, निर्दिष्ट प्रकार के सभी आंतरिक अपवादों की एक सूची देता है। InnerException और AggregateException.InnerException।

मेरी विशेष समस्या में, आंतरिक अपवादों का पीछा करना सामान्य से अधिक जटिल था, क्योंकि अपवादों को उन वर्गों के कंस्ट्रक्टर द्वारा फेंका जा रहा था जिन्हें प्रतिबिंब के माध्यम से आमंत्रित किया जा रहा था। जो अपवाद हम पकड़ रहे थे, उनमें इनरस्टेपेशन ऑफ़ टाइप इनवर्टेशन एक्सेप्शन था, और जिन अपवादों को हमें वास्तव में देखने की जरूरत थी, वे पेड़ में गहरे दबे हुए थे।

public static class ExceptionExtensions
{
    public static IEnumerable<T> innerExceptions<T>(this Exception ex)
        where T : Exception
    {
        var rVal = new List<T>();

        Action<Exception> lambda = null;
        lambda = (x) =>
        {
            var xt = x as T;
            if (xt != null)
                rVal.Add(xt);

            if (x.InnerException != null)
                lambda(x.InnerException);

            var ax = x as AggregateException;
            if (ax != null)
            {
                foreach (var aix in ax.InnerExceptions)
                    lambda(aix);
            }
        };

        lambda(ex);

        return rVal;
    }
}

उपयोग बहुत सरल है। यदि, उदाहरण के लिए, आप जानना चाहते हैं कि क्या हमने सामना किया

catch (Exception ex)
{
    var myExes = ex.innerExceptions<MyException>();
    if (myExes.Any(x => x.Message.StartsWith("Encountered my specific error")))
    {
        // ...
    }
}

Question 11

आप कहीं एक उपयोगिता वर्ग में एक विधि बनाने के लिए पुनरावृत्ति का उपयोग कर सकते हैं।

public Exception GetFirstException(Exception ex)
{
    if(ex.InnerException == null) { return ex; } // end case
    else { return GetFirstException(ex.InnerException); } // recurse
}

उपयोग:

try
{
    // some code here
}
catch (Exception ex)
{
    Exception baseException = GetFirstException(ex);
}

विस्तार विधि का सुझाव दिया (अच्छा विचार @dtb)

public static Exception GetFirstException(this Exception ex)
{
    if(ex.InnerException == null) { return ex; } // end case
    else { return GetFirstException(ex.InnerException); } // recurse
}

उपयोग:

try
{
    // some code here
}
catch (Exception ex)
{
    Exception baseException = ex.GetFirstException();
}

Question 12

एक और तरीका है कि आप इसे GetBaseException()दो बार कॉल कर सकते हैं :

Exception innermostException = e.GetBaseException().GetBaseException();

यह काम करता है क्योंकि यदि यह एक है AggregateException, तो पहली कॉल आपको अंतरतम में मिलती है- AggregateExceptionफिर दूसरी कॉल आपको उस अपवाद के अंतरतम अपवाद पर मिलती है। यदि पहला अपवाद कोई नहीं है AggregateException, तो दूसरा कॉल उसी अपवाद को वापस करता है।

Question 13

मैं इसमें भाग गया और अपवाद "स्टैक" से सभी अपवाद संदेशों को सूचीबद्ध करने में सक्षम होना चाहता था। इसलिए, मैं इसे लेकर आया हूं।

public static string GetExceptionMessages(Exception ex)
{
    if (ex.InnerException is null)
        return ex.Message;
    else return $"{ex.Message}\n{GetExceptionMessages(ex.InnerException)}";
}