it-swarm.com.de

Der beste Weg, um nach inneren Ausnahmen zu suchen?

Ich weiß, dass innerException manchmal null ist

Das Folgende könnte also fehlschlagen:

 repEvent.InnerException = ex.InnerException.Message; 

Gibt es eine schnelle ternäre Methode, um zu überprüfen, ob innerException null ist oder nicht?

51
JL.

Suchst du danach?

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

Tolle Antworten bis jetzt. Auf einer ähnlichen, aber unterschiedlichen Anmerkung gibt es manchmal mehr als eine Ebene verschachtelter Ausnahmen. Wenn Sie die ursprünglich ausgelöste Stammausnahme abrufen möchten, egal wie tief, versuchen Sie Folgendes:

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

        return ex.InnerException.GetOriginalException();
    }
}

Und im Einsatz:

repEvent.InnerException = ex.GetOriginalException();
77
jrista

Das ist lustig, ich kann nichts mit Exception.GetBaseException () finden.

repEvent.InnerException = ex.GetBaseException().Message;
39
csharptest.net

Die einfachste Lösung ist die Verwendung eines grundlegenden bedingten Ausdrucks:

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

Warum so viel Rekursion in diesen Antworten?

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

Es scheint eine viel einfachere Möglichkeit zu sein, dies umzusetzen.

11
Yaur

Es ist eine alte Frage, aber für zukünftige Leser:

Neben den bereits veröffentlichten Antworten, denke ich, ist der richtige Weg (wenn Sie mehr als eine InnerException haben können) Exception.GetBaseException Method

Wenn Sie die Ausnahmeinstanz möchten, sollten Sie Folgendes tun:

repEvent.InnerException = ex.GetBaseException();

Wenn Sie die Nachricht nur auf diese Weise suchen:

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

Mit C # 6.0 können Sie Folgendes verwenden:

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

Diese Codezeile ähnelt:

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

https://msdn.Microsoft.com/de-de/library/ty67wk28.aspx

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

8
Toddams

Manchmal hat InnerException auch eine InnerException, sodass Sie eine rekursive Funktion dafür verwenden können:

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

Mit C # 6.0 ist dies in einer Zeile möglich.

repEvent.InnerException = ex.InnerException?.Message; 

für andere Funktionen von C # 6.0 klicken Sie auf hier

4
Ashwin

Hier ist eine weitere mögliche Implementierung, die die Nachrichten und Stack-Traces anfügt, damit wir sie voll nutzen können: 

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);
}
1
Ognyan Dimitrov
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;
        }
    }
}
1
qwert_ukg

Mit diesem Code können Sie sicher sein, dass Sie keine inneren Ausnahmemeldungen verloren haben

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

Ja:

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

Es ist möglich, einen Ausnahmefilter zu verwenden, um eine genauere Ausrichtung zu erzielen.

catch (Exception ex) when (ex.InnerException != null) {...}

Weitere Details finden Sie hier

0
Valerii