Meilleur moyen de vérifier l'exception interne?

Question

Je sais que parfois innerException est nulle

Alors ce qui suit peut échouer:

repEvent.InnerException = ex.InnerException.Message; 

est-il un moyen rapide ternaire pour vérifier si innerException est nulle ou non?

Answer 1

Est-ce que vous cherchez?

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

Answer 2

Oui:

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

Answer 3

La solution la plus simple est d'utiliser une expression conditionnelle de base:

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

Answer 4

Excellentes réponses jusqu'à présent. Sur une note similaire, mais différente, il existe parfois plus d'un niveau d'exceptions imbriquées. Si vous voulez obtenir l'exception de la racine qui a été initialement lancée, peu importe la profondeur, vous pouvez essayer ceci:

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

     return ex.InnerException.GetOriginalException(); 
    } 
} 

Et utilisé:

repEvent.InnerException = ex.GetOriginalException(); 

Answer 5

Parfois aussi InnerException a une InnerException, vous peut utiliser une fonction récursive pour elle:

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

C'est drôle, je ne peux pas trouver quelque chose de mal avec Exception.GetBaseException()?

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

Answer 7

Son une vieille question, mais pour les futurs lecteurs:

En plus est Exception.GetBaseException Method

les réponses déjà affichées Je pense que la bonne façon de le faire (quand vous pouvez avoir plus d'un InnerException)

Si vous souhaitez que l'instance d'exception vous devriez faire ceci:

repEvent.InnerException = ex.GetBaseException(); 

Si vous cherchez seulement pour le message de cette façon:

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

Answer 8

Pourquoi tant de récursion dans ces réponses?

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

Cela semble être une façon beaucoup plus simple de mettre en œuvre ceci.

Answer 9

Voici une autre mise en œuvre possible que les messages et ajoute traces de pile de sorte que nous obtenons pleins:

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

Avec C# 6.0, vous pouvez utiliser:

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

Cette ligne de code est similaire à:

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

Avec ce code, vous serez sûr que vous did't perdre des messages d'exception interne

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

Answer 13

avec C# 6.0, vous pouvez le faire dans un ligne.

repEvent.InnerException = ex.InnerException?.Message; 

pour d'autres caractéristique de C# 6.0 cliquez here