¿Cuál es la forma correcta de mostrar la InnerException completa?

¿Cuál es la forma correcta de mostrar mi plenitud InnerException?

Descubrí que algunas de mis InnerExceptions tienen otra InnerExceptiony eso es bastante profundo.

¿Haré InnerException.ToString()el trabajo por mí o necesito recorrer InnerExceptionsy construir un Stringcon StringBuilder?

Simplemente puede imprimir exception.ToString(), eso también incluirá el texto completo de todos los correos InnerExceptionelectrónicos anidados .

Solo usa exception.ToString()

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

La implementación predeterminada de ToString obtiene el nombre de la clase que arrojó la excepción actual, el mensaje, el resultado de llamar a ToString en la excepción interna y el resultado de llamar a Environment.StackTrace. Si alguno de estos miembros es nulo, su valor no se incluye en la cadena devuelta.

Si no hay un mensaje de error o si se trata de una cadena vacía (""), no se devuelve ningún mensaje de error. El nombre de la excepción interna y el seguimiento de la pila se devuelven solo si no son nulos.

exception.ToString () también llamará a .ToString () en la excepción interna de esa excepción, y así sucesivamente ...

Por lo general, me gusta esto para eliminar la mayor parte del ruido:

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

    Console.WriteLine(realerror.ToString())
}    

Editar: Olvidé esta respuesta y me sorprende que nadie haya señalado que solo puedes hacer

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

La respuesta de @ Jon es la mejor solución cuando desea detalles completos (todos los mensajes y el seguimiento de la pila) y la recomendada.

Sin embargo, puede haber casos en los que solo desee los mensajes internos, y para estos casos uso el siguiente método de extensión:

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

A menudo uso este método cuando tengo diferentes oyentes para rastrear y registrar y quiero tener diferentes puntos de vista sobre ellos. De esa manera, puedo tener un oyente que envía el error completo con el seguimiento de la pila por correo electrónico al equipo de desarrollo para la depuración utilizando el .ToString()método y uno que escribe un archivo de inicio de sesión con el historial de todos los errores que ocurrieron cada día sin el seguimiento de la pila con El .GetFullMessage()método

Para imprimir solo la Messageparte de excepciones profundas, puede hacer algo como esto:

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

Esto atraviesa recursivamente todas las excepciones internas (incluido el caso de AggregateExceptions) para imprimir todas las Messagepropiedades contenidas en ellas, delimitadas por el salto de línea.

P.ej

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

Se produjo aggr externo.
Aggr interno ex.
El número no está en el formato correcto.
Acceso no autorizado a archivos.
No administrador

Necesitará escuchar otras propiedades de Excepción para más detalles. Por ejemplo Datatendrá alguna información. Podrías hacerlo:

foreach (DictionaryEntry kvp in exception.Data)

Para obtener todas las propiedades derivadas (no en la Exceptionclase base ), puede hacer:

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

Hago:

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

Esto "imprime" todas las excepciones internas y también maneja AggregateExceptions y casos donde InnerException.Message es lo mismo que Message

Si desea información sobre todas las excepciones, use exception.ToString() . Recopilará datos de todas las excepciones internas.

Si solo quieres la excepción original, úsala exception.GetBaseException().ToString(). Esto le dará la primera excepción, por ejemplo, la excepción interna más profunda o la excepción actual si no hay una excepción interna.

Ejemplo:

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
}

acumulación de la respuesta de nawfal.

cuando usé su respuesta faltaba una variable aggrEx, la agregué.

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