Quelle est la bonne façon d'afficher l'intégralité de InnerException?

Quelle est la bonne façon de montrer mon plein InnerException.

J'ai trouvé que certaines de mes InnerExceptions en ont une autre InnerExceptionet que cela est assez profond.

Fera InnerException.ToString()- t -il le travail pour moi ou dois-je parcourir le InnerExceptionset créer un Stringavec StringBuilder?

Vous pouvez simplement imprimer exception.ToString()- cela inclura également le texte intégral de tous les InnerExceptions imbriqués .

Juste utiliser exception.ToString()

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

L'implémentation par défaut de ToString obtient le nom de la classe qui a levé l'exception actuelle, le message, le résultat de l'appel de ToString sur l'exception interne et le résultat de l'appel de Environment.StackTrace. Si l'un de ces membres est nul, sa valeur n'est pas incluse dans la chaîne renvoyée.

S'il n'y a pas de message d'erreur ou s'il s'agit d'une chaîne vide (""), aucun message d'erreur n'est renvoyé. Le nom de l'exception interne et la trace de pile ne sont renvoyés que s'ils ne sont pas nuls.

exception.ToString () appellera également .ToString () sur l'exception interne de cette exception, et ainsi de suite ...

J'aime généralement ceci pour éliminer la plupart du bruit:

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

    Console.WriteLine(realerror.ToString())
}    

Edit: J'ai oublié cette réponse et je suis surpris que personne n'ait souligné que vous pouvez simplement le faire

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

La réponse de @ Jon est la meilleure solution lorsque vous voulez des détails complets (tous les messages et la trace de la pile) et celle recommandée.

Cependant, il peut y avoir des cas où vous ne voulez que les messages internes, et pour ces cas, j'utilise la méthode d'extension suivante:

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

J'utilise souvent cette méthode lorsque j'ai différents écouteurs pour le traçage et la journalisation et que je souhaite avoir des points de vue différents sur eux. De cette façon, je peux avoir un écouteur qui envoie toute l'erreur avec trace de pile par e-mail à l'équipe de développement pour le débogage à l'aide de la .ToString()méthode et un qui écrit un fichier journal avec l'historique de toutes les erreurs qui se sont produites chaque jour sans la trace de la pile avec la .GetFullMessage()méthode.

Pour n'imprimer que la Messagepartie des exceptions profondes, vous pouvez faire quelque chose comme ceci:

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

Cela parcourt de manière récursive toutes les exceptions internes (y compris le cas de AggregateExceptions) pour afficher toutes les Messagepropriétés qu'elles contiennent, délimitées par un saut de ligne.

Par exemple

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

Un agrex externe s'est produit.
Intérieur aggr ex.
Le nombre n'est pas au format correct.
Accès aux fichiers non autorisé.
Pas administrateur.

Vous devrez écouter les autres propriétés d' exception pour plus de détails. Par exemple Dataaura quelques informations. Vous pourriez faire:

foreach (DictionaryEntry kvp in exception.Data)

Pour obtenir toutes les propriétés dérivées (pas sur la Exceptionclasse de base ), vous pouvez faire:

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

Je fais:

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

Ce "joli imprime" toutes les exceptions internes et gère également les AggregateExceptions et les cas où InnerException.Message est identique à Message

Si vous voulez des informations sur toutes les exceptions, utilisez exception.ToString(). Il collectera les données de toutes les exceptions internes.

Si vous ne voulez que l'exception d'origine, utilisez exception.GetBaseException().ToString(). Cela vous donnera la première exception, par exemple l'exception interne la plus profonde ou l'exception actuelle s'il n'y a pas d'exception interne.

Exemple:

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
}

accumulation sur la réponse de nawfal.

lors de l'utilisation de sa réponse, il manquait une variable aggrEx, je l'ai ajoutée.

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