¿La forma correcta de encontrar la excepción más interna?

Question

Estoy trabajando con algunas clases que, al lanzar, tienen un árbol InnerException relativamente profundo. Me gustaría iniciar sesión y actuar sobre la excepción más interna, que es la que tiene la verdadera razón del problema.

Actualmente estoy usando algo similar a

public static Exception getInnermostException(Exception e) { 
    while (e.InnerException != null) { 
     e = e.InnerException; 
    } 
    return e; 
} 

Es esta la forma correcta de manejar árboles excepción?

Answer 1

creo que se puede conseguir la excepción interna usando el siguiente código:

public static Exception getInnermostException(Exception e) { 
    return e.GetBaseException(); 
} 

Answer 2

En una palabra, sí. No puedo pensar en ninguna manera significativamente mejor o diferente de hacerlo. A menos que quieras agregarlo como método de extensión, pero en realidad es seis de una, media docena de la otra.

Answer 3

Puede utilizar el método GetBaseException. ejemplo muy rápida:

try 
{ 
    try 
    { 
     throw new ArgumentException("Innermost exception"); 
    } 
    catch (Exception ex) 
    { 
     throw new Exception("Wrapper 1",ex); 
    } 
} 
catch (Exception ex) 
{ 
    // Writes out the ArgumentException details 
    Console.WriteLine(ex.GetBaseException().ToString()); 
} 

Answer 4

hay excepciones que pueden tener múltiples causas fundamentales (por ejemplo AggregateException y ReflectionTypeLoadException).

Creé mi propio class para navegar por el árbol y luego diferentes visitantes recolectan todo o solo las causas principales. Salidas de muestra here. Pedazo de código relevante a continuación.

public void Accept(ExceptionVisitor visitor) 
{ 
    Read(this.exception, visitor); 
} 

private static void Read(Exception ex, ExceptionVisitor visitor) 
{ 
    bool isRoot = ex.InnerException == null; 
    if (isRoot) 
    { 
     visitor.VisitRootCause(ex); 
    } 

    visitor.Visit(ex); 
    visitor.Depth++; 

    bool isAggregateException = TestComplexExceptionType<AggregateException>(ex, visitor, aggregateException => aggregateException.InnerExceptions); 
    TestComplexExceptionType<ReflectionTypeLoadException>(ex, visitor, reflectionTypeLoadException => reflectionTypeLoadException.LoaderExceptions); 

    // aggregate exceptions populate the first element from InnerExceptions, so no need to revisit 
    if (!isRoot && !isAggregateException) 
    { 
     visitor.VisitInnerException(ex.InnerException); 
     Read(ex.InnerException, visitor); 
    } 

    // set the depth back to current context 
    visitor.Depth--; 
} 

private static bool TestComplexExceptionType<T>(Exception ex, ExceptionVisitor visitor, Func<T, IEnumerable<Exception>> siblingEnumerator) where T : Exception 
{ 
    var complexException = ex as T; 
    if (complexException == null) 
    { 
     return false; 
    } 

    visitor.VisitComplexException(ex); 

    foreach (Exception sibling in siblingEnumerator.Invoke(complexException)) 
    { 
     visitor.VisitSiblingInnerException(sibling); 
     Read(sibling, visitor); 
    } 

    return true; 
}