¿La mejor manera de verificar la excepción interna?

Question

Sé que a veces es nula InnerException

Así que el siguiente puede fallar:

repEvent.InnerException = ex.InnerException.Message; 

¿Hay alguna forma ternaria rápida de comprobar si InnerException es nulo o no?

Answer 1

Es esto lo que busca?

String innerMessage = (ex.InnerException != null) 
         ? ex.InnerException.Message 
         : ""; 

Answer 2

Sí:

if (ex.InnerException == null) { 
    // then it's null 
} 

Answer 3

La solución más simple es utilizar una expresión condicional básica:

repEvent.InnerException = ex.InnerException == null ? 
    null : ex.InnerException.Message; 

Answer 4

Grandes respuestas hasta el momento. En una nota similar pero diferente, a veces hay más de un nivel de excepciones anidadas. Si desea obtener la excepción de la raíz que fue lanzado originalmente, sin importar la profundidad, es posible que intente esto:

public static class ExceptionExtensions 
{ 
    public static Exception GetOriginalException(this Exception ex) 
    { 
     if (ex.InnerException == null) return ex; 

     return ex.InnerException.GetOriginalException(); 
    } 
} 

Y en uso:

repEvent.InnerException = ex.GetOriginalException(); 

Answer 5

A veces también InnerException tiene una InnerException, por lo que se puede utilizar una función recursiva para ello:

public string GetInnerException(Exception ex) 
{ 
    if (ex.InnerException != null) 
    { 
     return string.Format("{0} > {1} ", ex.InnerException.Message, GetInnerException(ex.InnerException)); 
    } 
    return string.Empty; 
} 

Answer 6

Eso es gracioso, no puedo encontrar nada malo en Exception.GetBaseException()?

repEvent.InnerException = ex.GetBaseException().Message; 

Answer 7

Es un antiguo pregunta, pero para los futuros lectores:

Además de las respuestas ya publicadas Creo que la forma correcta de hacer esto (cuando se puede tener más de un InnerException) es Exception.GetBaseException Method

Si desea que la instancia de excepción que debe hacer esto:

repEvent.InnerException = ex.GetBaseException(); 

Si sólo busca el mensaje de esta manera:

repEvent.InnerException = ex.GetBaseException().Message; 

Answer 8

¿Por qué tanto recursividad en estas respuestas?

public static class ExceptionExtensions 
{ 
    public static Exception GetOriginalException(this Exception ex) 
    { 
     while(ex.InnerException != null)ex = ex.InnerException; 
     return ex; 
    } 
} 

Parece una forma mucho más directa de implementar esto.

Answer 9

Aquí es otra posible aplicación que añade los mensajes y las trazas de la pila por lo que los conseguimos completo:

private static Tuple<string, string> GetFullExceptionMessageAndStackTrace(Exception exception) 
{ 
    if (exception.InnerException == null) 
    { 
     if (exception.GetType() != typeof(ArgumentException)) 
     { 
      return new Tuple<string, string>(exception.Message, exception.StackTrace); 
     } 
     string argumentName = ((ArgumentException)exception).ParamName; 
     return new Tuple<string, string>(String.Format("{0} With null argument named '{1}'.", exception.Message, argumentName), exception.StackTrace); 
    } 
    Tuple<string, string> innerExceptionInfo = GetFullExceptionMessageAndStackTrace(exception.InnerException); 
    return new Tuple<string, string>(
    String.Format("{0}{1}{2}", innerExceptionInfo.Item1, Environment.NewLine, exception.Message), 
    String.Format("{0}{1}{2}", innerExceptionInfo.Item2, Environment.NewLine, exception.StackTrace)); 
} 


[Fact] 
public void RecursiveExtractingOfExceptionInformationOk() 
{ 
    // Arrange 
    Exception executionException = null; 
    var iExLevelTwo = new NullReferenceException("The test parameter is null"); 
    var iExLevelOne = new ArgumentException("Some test meesage", "myStringParamName", iExLevelTwo); 
    var ex = new Exception("Some higher level message",iExLevelOne); 

    // Act 
    var exMsgAndStackTrace = new Tuple<string, string>("none","none"); 
    try 
    { 
     exMsgAndStackTrace = GetFullExceptionMessageAndStackTrace(ex); 
    } 
    catch (Exception exception) 
    { 
     executionException = exception; 
    } 

    // Assert 
    Assert.Null(executionException); 

    Assert.True(exMsgAndStackTrace.Item1.Contains("The test parameter is null")); 
    Assert.True(exMsgAndStackTrace.Item1.Contains("Some test meesage")); 
    Assert.True(exMsgAndStackTrace.Item1.Contains("Some higher level message")); 
    Assert.True(exMsgAndStackTrace.Item1.Contains("myStringParamName")); 

    Assert.True(!string.IsNullOrEmpty(exMsgAndStackTrace.Item2)); 

    Console.WriteLine(exMsgAndStackTrace.Item1); 
    Console.WriteLine(exMsgAndStackTrace.Item2); 
} 

Answer 10

con C# 6.0 que puede utilizar:

string message = exception.InnerException?.Message ?? "";

Esta línea de código es similar a:

string message = exception.InnerException == null ? "" : exception.InnerException.Message.

https://msdn.microsoft.com/en-us/library/ty67wk28.aspx

http://blogs.msdn.com/b/jerrynixon/archive/2014/02/26/at-last-c-is-getting-sometimes-called-the-safe-navigation-operator.aspx

Answer 11

class MyException : Exception 
{ 
    private const string AMP = "\r\nInnerException: "; 
    public override string Message 
    { 
     get 
     { 
      return this.InnerException != null ? base.Message + AMP + this.InnerException.Message : base.Message; 
     } 
    } 

    public override string StackTrace 
    { 
     get 
     { 
      return this.InnerException != null ? base.StackTrace + AMP + this.InnerException.StackTrace : base.StackTrace; 
     } 
    } 
} 

Answer 12

Con este código podrá estar seguro de que did't perder ningún mensaje de excepción interiores

catch (Exception exception) 
{ 
    Logger.Error(exception.Message); 
    while (exception.InnerException != null) 
    { 
     exception = exception.InnerException; 
     Logger.Error(exception); 
    } 
} 

Answer 13

con C# 6.0 se puede hacer en un solo línea.

repEvent.InnerException = ex.InnerException?.Message; 

para otra característica de C# 6.0 clic here