Wie kann die vollständige InnerException richtig angezeigt werden?

Was ist der richtige Weg, um meine volle zu zeigen InnerException.

Ich habe festgestellt, dass einige meiner InnerExceptions eine andere haben InnerExceptionund das geht ziemlich tief.

Erledige InnerException.ToString()ich den Job für mich oder muss ich das durchlaufen InnerExceptionsund ein Stringmit aufbauen StringBuilder?

Sie können einfach drucken exception.ToString()- dazu gehört auch der vollständige Text für alle verschachtelten InnerExceptions.

Benutz einfach exception.ToString()

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

Die Standardimplementierung von ToString erhält den Namen der Klasse, die die aktuelle Ausnahme ausgelöst hat, die Nachricht, das Ergebnis des Aufrufs von ToString für die innere Ausnahme und das Ergebnis des Aufrufs von Environment.StackTrace. Wenn eines dieser Elemente null ist, ist sein Wert nicht in der zurückgegebenen Zeichenfolge enthalten.

Wenn keine Fehlermeldung vorliegt oder wenn es sich um eine leere Zeichenfolge ("") handelt, wird keine Fehlermeldung zurückgegeben. Der Name der inneren Ausnahme und die Stapelverfolgung werden nur zurückgegeben, wenn sie nicht null sind.

exception.ToString () ruft auch .ToString () für die innere Ausnahme dieser Ausnahme auf und so weiter ...

Normalerweise mag ich das, um den größten Teil des Rauschens zu entfernen:

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

    Console.WriteLine(realerror.ToString())
}    

Bearbeiten: Ich habe diese Antwort vergessen und bin überrascht, dass niemand darauf hingewiesen hat, dass Sie einfach tun können

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

Die Antwort von @ Jon ist die beste Lösung, wenn Sie alle Details (alle Nachrichten und die Stapelverfolgung) und die empfohlene Lösung wünschen.

Es kann jedoch Fälle geben, in denen Sie nur die inneren Nachrichten möchten, und für diese Fälle verwende ich die folgende Erweiterungsmethode:

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

Ich verwende diese Methode oft, wenn ich unterschiedliche Listener zum Verfolgen und Protokollieren habe und unterschiedliche Ansichten zu ihnen haben möchte. Auf diese Weise kann ich einen Listener haben, der den gesamten Fehler mit Stack-Trace per E-Mail an das Entwicklerteam zum Debuggen mit der .ToString()Methode sendet , und einen, der eine Anmeldedatei mit dem Verlauf aller Fehler schreibt, die jeden Tag ohne den Stack-Trace mit aufgetreten sind die .GetFullMessage()Methode.

Um nur den MessageTeil der tiefen Ausnahmen hübsch auszudrucken , können Sie Folgendes tun:

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

Dies durchläuft rekursiv alle inneren Ausnahmen (einschließlich des Falls von AggregateExceptions), um alle darin Messageenthaltenen Eigenschaften zu drucken , die durch Zeilenumbrüche begrenzt sind.

Z.B

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());

Äußerer Aggr ex trat auf.
Innerer Aggr.
Die Nummer hat nicht das richtige Format.
Nicht autorisierter Dateizugriff.
Kein Administrator.

Sie müssen andere Ausnahmeeigenschaften anhören, um weitere Details zu erhalten. Zum Beispiel Datawird einige Informationen haben. Du könntest es tun:

foreach (DictionaryEntry kvp in exception.Data)

Um alle abgeleiteten Eigenschaften (nicht für die Basisklasse Exception) abzurufen, können Sie Folgendes tun:

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

Ich mache:

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

Dies "druckt" alle inneren Ausnahmen und behandelt auch AggregateExceptions und Fälle, in denen InnerException.Message mit Message identisch ist

Wenn Sie Informationen zu allen Ausnahmen wünschen, verwenden Sie exception.ToString(). Es werden Daten aus allen inneren Ausnahmen gesammelt.

Wenn Sie nur die ursprüngliche Ausnahme möchten, verwenden Sie exception.GetBaseException().ToString(). Dadurch erhalten Sie die erste Ausnahme, z. B. die tiefste innere Ausnahme oder die aktuelle Ausnahme, wenn keine innere Ausnahme vorliegt.

Beispiel:

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
}

Aufbau auf Nawfals Antwort.

Als ich seine Antwort verwendete, fehlte eine Variable aggrEx. Ich fügte sie hinzu.

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