Trova l'eccezione più interna senza utilizzare un ciclo while?

Question

Quando C# genera un'eccezione, può presentare un'eccezione interna. Quello che voglio fare è ottenere l'eccezione più interna, o in altre parole, l'eccezione foglia che non ha un'eccezione interna. Posso fare questo in un ciclo while:

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

ma mi chiedevo se ci fosse qualche one-liner potrei usare per fare questo, invece.

Answer 1

Oneliner :)

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

Ovviamente, non si può far più semplice.

Come detto in this answer da Glenn McElhoe, è l'unico modo affidabile.

Answer 2

È possibile utilizzare la ricorsione per creare un metodo in una classe di utilità da qualche parte.

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

Usa:

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

Il metodo di estensione suggerito (buona idea @dtb)

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

Usa:

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

Answer 3

Se non sai quanto è profonda le eccezioni interne sono annidate, non c'è modo di aggirare un ciclo o ricorsione.

Naturalmente, è possibile definire un metodo di estensione che astrae questa via:

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

Answer 4

A volte si potrebbe avere molte eccezioni interne (molte eccezioni gorgogliare). Nel qual caso si potrebbe desiderare di fare:

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

Answer 5

Non proprio una riga ma quasi:

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

Answer 6

Credo Exception.GetBaseException() fa la stessa cosa di queste soluzioni. http://msdn.microsoft.com/en-us/library/system.exception.getbaseexception(v=vs.71).aspx

Caveat: Da vari commenti abbiamo capito che non sempre letteralmente fare la stessa cosa, e in alcuni casi la soluzione/iterazione ricorsiva ti porterà ulteriormente. È di solito l'eccezione più interna, che è deludentemente incoerente, grazie a determinati tipi di eccezioni che sostituiscono il valore predefinito. Tuttavia, se rilevi tipi specifici di eccezioni e assicuri ragionevolmente che non sono strane (come AggregateException), allora mi aspetterei che ottenga l'eccezione legittima/iniziale più antica.

Answer 7

In effetti è così semplice, si potrebbe usare Exception.GetBaseException()

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

Answer 8

So che questo è un vecchio post, ma sono sorpreso nessuno ha chiesto GetBaseException() che è un metodo della classe Exception:

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

Questo è stato in giro da. NET 1.1. Documentazione qui: http://msdn.microsoft.com/en-us/library/system.exception.getbaseexception(v=vs.71).aspx

Answer 9

Il looping attraverso InnerExceptions è l'unico modo affidabile.

Se l'eccezione rilevata è un'eccezione Aggregate, quindi GetBaseException() restituisce solo l'eccezione AggregateException più interna.

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

Answer 10

Devi loop, e di dover ciclo, è più pulito di spostare l'anello in una funzione separata.

Ho creato un metodo di estensione per affrontare questo. Restituisce un elenco di tutte le eccezioni interne del tipo specificato, inseguendo Exception.InnerException e AggregateException.InnerExceptions.

Nel mio particolare problema, rincorrere le eccezioni interne era più complicato del solito, perché le eccezioni venivano lanciate dai costruttori delle classi che venivano invocate attraverso la riflessione. L'eccezione che stavamo catturando aveva una InnerException di tipo TargetInvocationException, e le eccezioni che dovevamo effettivamente vedere erano sepolte in profondità nell'albero.

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

L'utilizzo è piuttosto semplice. Se, per esempio, si desidera sapere se abbiamo incontrato un

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