Qual è il modo corretto di visualizzare la InnerException completa?

Qual è il modo corretto di mostrare il mio pieno InnerException.

Ho scoperto che alcune delle mie InnerExceptions ne hanno un'altra InnerExceptione che vanno molto in profondità.

Farà InnerException.ToString()il lavoro per me o devo passare in rassegna il InnerExceptionse creare un Stringcon StringBuilder?

Puoi semplicemente stampare exception.ToString()- che includerà anche il testo completo per tutti i messaggi nidificati InnerException.

Basta usare exception.ToString()

http://msdn.microsoft.com/en-us/library/system.exception.tostring.aspx

L'implementazione predefinita di ToString ottiene il nome della classe che ha generato l'eccezione corrente, il messaggio, il risultato della chiamata a ToString sull'eccezione interna e il risultato della chiamata di Environment.StackTrace. Se uno di questi membri è nullo, il suo valore non è incluso nella stringa restituita.

Se non è presente alcun messaggio di errore o se si tratta di una stringa vuota (""), non viene restituito alcun messaggio di errore. Il nome dell'eccezione interna e la traccia dello stack vengono restituiti solo se non sono nulli.

exception.ToString () chiamerà anche .ToString () sull'eccezione interna di quell'eccezione, e così via ...

Di solito mi piace in questo modo per rimuovere la maggior parte del rumore:

void LogException(Exception error) {
    Exception realerror = error;
    while (realerror.InnerException != null)
        realerror = realerror.InnerException;

    Console.WriteLine(realerror.ToString())
}    

Modifica: ho dimenticato questa risposta e sono sorpreso che nessuno abbia sottolineato che puoi semplicemente farlo

void LogException(Exception error) {
    Console.WriteLine(error.GetBaseException().ToString())
}    

@La risposta di Jon è la soluzione migliore quando vuoi tutti i dettagli (tutti i messaggi e la traccia dello stack) e quella consigliata.

Tuttavia, potrebbero esserci casi in cui desideri solo i messaggi interni e per questi casi utilizzo il seguente metodo di estensione:

public static class ExceptionExtensions
{
    public static string GetFullMessage(this Exception ex)
    {
        return ex.InnerException == null 
             ? ex.Message 
             : ex.Message + " --> " + ex.InnerException.GetFullMessage();
    }
}

Uso spesso questo metodo quando ho ascoltatori diversi per tracciare e registrare e voglio avere visioni diverse su di essi. In questo modo posso avere un ascoltatore che invia l'intero errore con la traccia dello stack via e-mail al team di sviluppo per il debug utilizzando il .ToString()metodo e uno che scrive un file di accesso con la cronologia di tutti gli errori che si sono verificati ogni giorno senza la traccia dello stack con il .GetFullMessage()metodo.

Per stampare piuttosto solo la Messageparte delle eccezioni profonde, potresti fare qualcosa del genere:

public static string ToFormattedString(this Exception exception)
{
    IEnumerable<string> messages = exception
        .GetAllExceptions()
        .Where(e => !String.IsNullOrWhiteSpace(e.Message))
        .Select(e => e.Message.Trim());
    string flattened = String.Join(Environment.NewLine, messages); // <-- the separator here
    return flattened;
}

public static IEnumerable<Exception> GetAllExceptions(this Exception exception)
{
    yield return exception;

    if (exception is AggregateException aggrEx)
    {
        foreach (Exception innerEx in aggrEx.InnerExceptions.SelectMany(e => e.GetAllExceptions()))
        {
            yield return innerEx;
        }
    }
    else if (exception.InnerException != null)
    {
        foreach (Exception innerEx in exception.InnerException.GetAllExceptions())
        {
            yield return innerEx;
        }
    }
}

Ciò ricorre in modo ricorsivo a tutte le eccezioni interne (incluso il caso di AggregateExceptions) per stampare tutte le Messageproprietà in esse contenute, delimitate dall'interruzione di riga.

Per esempio

var outerAggrEx = new AggregateException(
    "Outer aggr ex occurred.",
    new AggregateException("Inner aggr ex.", new FormatException("Number isn't in correct format.")),
    new IOException("Unauthorized file access.", new SecurityException("Not administrator.")));
Console.WriteLine(outerAggrEx.ToFormattedString());

Si è verificato un errore esterno.
Inner aggr ex.
Il numero non è nel formato corretto.
Accesso ai file non autorizzato.
Non amministratore.

Sarà necessario ascoltare altre proprietà delle eccezioni per maggiori dettagli. Per esempio Dataavrà alcune informazioni. Potresti fare:

foreach (DictionaryEntry kvp in exception.Data)

Per ottenere tutte le proprietà derivate (non sulla Exceptionclasse base ), puoi fare:

exception
    .GetType()
    .GetProperties()
    .Where(p => p.CanRead)
    .Where(p => p.GetMethod.GetBaseDefinition().DeclaringType != typeof(Exception));

Lo voglio:

namespace System {
  public static class ExtensionMethods {
    public static string FullMessage(this Exception ex) {
      if (ex is AggregateException aex) return aex.InnerExceptions.Aggregate("[ ", (total, next) => $"{total}[{next.FullMessage()}] ") + "]";
      var msg = ex.Message.Replace(", see inner exception.", "").Trim();
      var innerMsg = ex.InnerException?.FullMessage();
      if (innerMsg is object && innerMsg!=msg) msg = $"{msg} [ {innerMsg} ]";
      return msg;
    }
  }
}

Questo "stampa" tutte le eccezioni interne e gestisce anche AggregateExceptions e casi in cui InnerException.Message è uguale a Message

Se desideri informazioni su tutte le eccezioni, utilizza exception.ToString(). Raccoglierà dati da tutte le eccezioni interne.

Se si desidera solo l'eccezione originale, utilizzare exception.GetBaseException().ToString(). In questo modo otterrai la prima eccezione, ad esempio l'eccezione interna più profonda o l'eccezione corrente se non esiste un'eccezione interna.

Esempio:

try {
    Exception ex1 = new Exception( "Original" );
    Exception ex2 = new Exception( "Second", ex1 );
    Exception ex3 = new Exception( "Third", ex2 );
    throw ex3;
} catch( Exception ex ) {
    // ex => ex3
    Exception baseEx = ex.GetBaseException(); // => ex1
}

accumulo sulla risposta di nawfal.

quando ho usato la sua risposta c'era una variabile aggrEx mancante, l'ho aggiunta.

file ExceptionExtenstions.class:

// example usage:
// try{ ... } catch(Exception e) { MessageBox.Show(e.ToFormattedString()); }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace YourNamespace
{
    public static class ExceptionExtensions
    {

        public static IEnumerable<Exception> GetAllExceptions(this Exception exception)
        {
            yield return exception;

            if (exception is AggregateException )
            {
                var aggrEx = exception as AggregateException;
                foreach (Exception innerEx in aggrEx.InnerExceptions.SelectMany(e => e.GetAllExceptions()))
                {
                    yield return innerEx;
                }
            }
            else if (exception.InnerException != null)
            {
                foreach (Exception innerEx in exception.InnerException.GetAllExceptions())
                {
                    yield return innerEx;
                }
            }
        }


        public static string ToFormattedString(this Exception exception)
        {
            IEnumerable<string> messages = exception
                .GetAllExceptions()
                .Where(e => !String.IsNullOrWhiteSpace(e.Message))
                .Select(exceptionPart => exceptionPart.Message.Trim() + "\r\n" + (exceptionPart.StackTrace!=null? exceptionPart.StackTrace.Trim():"") );
            string flattened = String.Join("\r\n\r\n", messages); // <-- the separator here
            return flattened;
        }
    }
}