Jaki jest właściwy sposób wyświetlania pełnego wyjątku InnerException?

Jaki jest właściwy sposób, aby pokazać moje pełne InnerException.

Okazało się, że niektóre z moich wyjątków InnerExceptions mają inny, InnerExceptionktóry jest dość głęboki.

Czy InnerException.ToString()wykona pracę za mnie, czy muszę przejść przez pętlę InnerExceptionsi zbudować Stringz StringBuilder?

Możesz po prostu wydrukować exception.ToString()- będzie to również zawierać pełny tekst dla wszystkich zagnieżdżonych plików InnerException.

Po prostu użyj exception.ToString()

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

Domyślna implementacja ToString uzyskuje nazwę klasy, która zgłosiła bieżący wyjątek, komunikat, wynik wywołania ToString w przypadku wyjątku wewnętrznego oraz wynik wywołania Environment.StackTrace. Jeśli którykolwiek z tych elementów członkowskich ma wartość null, jego wartość nie jest uwzględniana w zwracanym ciągu.

Jeśli nie ma komunikatu o błędzie lub jeśli jest to pusty ciąg („”), nie jest zwracany żaden komunikat o błędzie. Nazwa wewnętrznego wyjątku i ślad stosu są zwracane tylko wtedy, gdy nie są puste.

wyjątek.ToString () wywoła również funkcję .ToString () na wyjątku wewnętrznym tego wyjątku i tak dalej ...

Zwykle robię to, aby usunąć większość szumów:

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

    Console.WriteLine(realerror.ToString())
}    

Edycja: zapomniałem o tej odpowiedzi i jestem zaskoczony, że nikt nie wskazał, że możesz to zrobić

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

Odpowiedź @ Jona jest najlepszym rozwiązaniem, jeśli chcesz uzyskać pełne szczegóły (wszystkie wiadomości i ślad stosu) i zalecane.

Mogą się jednak zdarzyć sytuacje, w których potrzebujesz tylko komunikatów wewnętrznych, w takich przypadkach używam następującej metody rozszerzenia:

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

Często używam tej metody, gdy mam różnych słuchaczy do śledzenia i rejestrowania i chcę mieć różne poglądy na ich temat. W ten sposób mogę mieć jednego odbiornika, który wysyła cały błąd ze śladem stosu pocztą e-mail do zespołu programistów w celu debugowania przy użyciu .ToString()metody, oraz jednego, który zapisuje plik dziennika z historią wszystkich błędów, które zdarzały się każdego dnia bez śladu stosu z .GetFullMessage()metodą.

Aby całkiem wydrukować tylko Messageczęść głębokich wyjątków, możesz zrobić coś takiego:

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

To rekursywnie przechodzi przez wszystkie wewnętrzne wyjątki (w tym przypadek AggregateExceptions), aby wypisać wszystkie Messagezawarte w nich właściwości, rozdzielone podziałem wiersza.

Na przykład

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

Wystąpiła zewnętrzna aggr ex.
Wewnętrzny aggr ex.
Numer ma nieprawidłowy format.
Nieautoryzowany dostęp do plików.
Nie administrator.

Aby uzyskać więcej informacji, należy posłuchać innych właściwości wyjątku . Na przykład Databędzie miał jakieś informacje. Mógłbyś:

foreach (DictionaryEntry kvp in exception.Data)

Aby uzyskać wszystkie właściwości pochodne (nie w Exceptionklasie bazowej ), możesz zrobić:

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

Ja robię:

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

To „ładnie wypisuje” wszystkie wewnętrzne wyjątki, a także obsługuje AggregateExceptions i przypadki, w których InnerException.Message jest takie samo jak Message

Jeśli chcesz uzyskać informacje o wszystkich wyjątkach, użyj exception.ToString(). Będzie zbierać dane ze wszystkich wyjątków wewnętrznych.

Jeśli chcesz tylko oryginalny wyjątek, użyj exception.GetBaseException().ToString(). W ten sposób otrzymasz pierwszy wyjątek, np. Najgłębszy wyjątek wewnętrzny lub bieżący wyjątek, jeśli nie ma wyjątku wewnętrznego.

Przykład:

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
}

narastanie odpowiedzi nawfala.

używając jego odpowiedzi, brakowało zmiennej aggrEx, dodałem ją.

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