Bir while döngüsü kullanmadan en içteki istisnayı bulmak mı?

C # bir istisna attığında, bir iç istisnaya sahip olabilir. Yapmak istediğim, en içteki istisnayı veya başka bir deyişle, iç istisnası olmayan yaprak istisnasını elde etmek. Bunu bir süre döngüsünde yapabilirim:

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

Ama bunun yerine bunu yapmak için kullanabileceğim bir tek astar olup olmadığını merak ediyordum.

Oneliner :)

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

Açıkçası, bunu daha basit hale getiremezsiniz.

Glenn McElhoe'nun bu cevabında söylediği gibi , tek güvenilir yol bu.

Exception.GetBaseException()Bu çözümlerle aynı şeyi yaptığına inanıyorum .

Uyarı: Çeşitli yorumlardan, bunun her zaman tam anlamıyla aynı şeyi yapmadığını ve bazı durumlarda yinelemeli / yinelemeli çözümün sizi daha da ileriye götüreceğini anladık. Varsayılanı geçersiz kılan belirli İstisna türleri sayesinde , genellikle hayal kırıklığı yaratacak şekilde tutarsız olan en içteki istisnadır. Bununla birlikte, belirli istisna türlerini yakalarsanız ve tuhaf olmadıklarından makul ölçüde emin olursanız (AggregateException gibi), o zaman meşru en içteki / en erken istisnayı almasını beklerim.

InnerExceptions üzerinden döngü yapmak tek güvenilir yoldur.

Yakalanan istisna bir AggregateException ise, GetBaseException()yalnızca en içteki AggregateException'ı döndürür.

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

İç istisnaların ne kadar derinlemesine iç içe olduğunu bilmiyorsanız, bir döngü veya özyinelemenin etrafından dolaşmanın yolu yoktur.

Elbette, bunu soyutlayan bir uzatma yöntemi tanımlayabilirsiniz:

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

Bunun eski bir gönderi olduğunu biliyorum, ancak kimsenin sınıfta GetBaseException()bir yöntem olduğunu önermesine şaşırdım Exception:

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

Bu, .NET 1.1'den beri var. Buradaki belgeler: http://msdn.microsoft.com/en-us/library/system.exception.getbaseexception(v=vs.71).aspx

Bazen birçok iç istisnanız olabilir (birçok istisnai durum). Bu durumda şunları yapmak isteyebilirsiniz:

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

Tam olarak tek satır değil ama yakın:

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

Aslında çok basit, kullanabilirsin Exception.GetBaseException()

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

Döngü yapmanız ve döngü yapmanız gerekir, döngüyü ayrı bir işleve taşımak daha temizdir.

Bununla başa çıkmak için bir uzatma yöntemi oluşturdum. Exception.InnerException ve AggregateException.InnerExceptions 'ı takip ederek, belirtilen türün tüm iç özel durumlarının bir listesini döndürür.

Benim özel sorunumda, iç istisnaların peşinden gitmek her zamankinden daha karmaşıktı çünkü istisnalar, yansıtma yoluyla çağrılan sınıfların kurucuları tarafından fırlatılıyordu. Yakaladığımız istisna, TargetInvocationException türünde bir InnerException'a sahipti ve gerçekten bakmamız gereken istisnalar ağacın derinliklerine gömülmüştü.

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

Kullanımı oldukça basittir. Örneğin, bir sorunla karşılaşıp karşılaşmadığımızı bilmek istiyorsanız

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

Bir yerde bir yardımcı program sınıfında bir yöntem oluşturmak için özyinelemeyi kullanabilirsiniz.

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

Kullanım:

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

Uzantı yöntemi önerildi (iyi fikir @dtb)

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

Kullanım:

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

Bunu yapmanın başka bir yolu da GetBaseException()iki kez aramaktır:

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

Bu işe yarar çünkü eğer o bir AggregateExceptionise, ilk çağrı sizi en içteki olmayana götürür, AggregateExceptiono zaman ikinci çağrı sizi bu istisnanın en içteki istisnasına götürür. İlk istisna bir değilse AggregateException, ikinci çağrı sadece aynı istisnayı döndürür.

Bununla karşılaştım ve istisna "yığını" ndaki tüm istisna mesajlarını listeleyebilmek istedim. Ben de bunu buldum.

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