Bewährte Verfahren für das Abfangen und erneute Auslösen von .NET-Ausnahmen

Question

Was sind die besten Praktiken, die beim Abfangen von Ausnahmen und dem erneuten Auswerfen von Ausnahmen zu berücksichtigen sind? Ich möchte sicherstellen, dass die Exception das Objekt InnerException und die Stapelverfolgung werden beibehalten. Gibt es einen Unterschied zwischen den folgenden Codeblöcken in der Art und Weise, wie sie dies handhaben?

try
{
    //some code
}
catch (Exception ex)
{
    throw ex;
}

Vs:

try
{
    //some code
}
catch
{
    throw;
}

Answer 1

Der Weg, den Stack-Trace zu erhalten, ist die Verwendung der Option throw; Dies gilt auch für

try {
  // something that bombs here
} catch (Exception ex)
{
    throw;
}

throw ex; ist im Grunde wie das Auslösen einer Ausnahme von diesem Punkt aus, so dass der Stack-Trace nur bis zu dem Punkt gehen würde, an dem Sie die Ausgabe der throw ex; Erklärung.

Mike ist ebenfalls korrekt, vorausgesetzt, die Ausnahme erlaubt es Ihnen, eine Ausnahme zu übergeben (was empfohlen wird).

Karl Seguin hat eine großartiger Bericht über die Behandlung von Ausnahmen in seinem Grundlagen der Programmierung E-Book die ebenfalls sehr lesenswert ist.

Bearbeiten: Funktionierender Link zu Grundlagen der Programmierung pdf. Suchen Sie einfach im Text nach "Ausnahme".

Answer 2

Wenn Sie eine neue Ausnahme mit der ursprünglichen Ausnahme auslösen, bleibt auch die ursprüngliche Stapelverfolgung erhalten.

try{
} 
catch(Exception ex){
     throw new MoreDescriptiveException("here is what was happening", ex);
}

Answer 3

Tatsächlich gibt es einige Situationen, in denen die throw wird die StackTrace-Information nicht erhalten. Zum Beispiel im folgenden Code:

try
{
  int i = 0;
  int j = 12 / i; // Line 47
  int k = j + 1;
}
catch
{
  // do something
  // ...
  throw; // Line 54
}

Der StackTrace zeigt an, dass Zeile 54 die Ausnahme ausgelöst hat, obwohl sie in Zeile 47 ausgelöst wurde.

Unhandled Exception: System.DivideByZeroException: Attempted to divide by zero.
   at Program.WithThrowIncomplete() in Program.cs:line 54
   at Program.Main(String[] args) in Program.cs:line 106

In Situationen wie der oben beschriebenen gibt es zwei Möglichkeiten, den ursprünglichen StackTrace zu erhalten:

Aufrufen der Funktion Exception.InternalPreserveStackTrace

Da es sich um eine private Methode handelt, muss sie mit Hilfe von Reflection aufgerufen werden:

private static void PreserveStackTrace(Exception exception)
{
  MethodInfo preserveStackTrace = typeof(Exception).GetMethod("InternalPreserveStackTrace",
    BindingFlags.Instance | BindingFlags.NonPublic);
  preserveStackTrace.Invoke(exception, null);
}

I hat den Nachteil, dass die StackTrace-Informationen von einer privaten Methode abhängen. Dies kann in zukünftigen Versionen von .NET Framework geändert werden. Das obige Code-Beispiel und die vorgeschlagene Lösung wurden entnommen aus Weblog von Fabrice MARGUERIE .

Aufruf von Exception.SetObjectData

Die folgende Technik wurde vorgeschlagen von Anton Tykhyy als Antwort auf In C#, wie kann ich rethrow InnerException ohne Stack-Trace zu verlieren Frage.

static void PreserveStackTrace (Exception e) 
{ 
  var ctx = new StreamingContext  (StreamingContextStates.CrossAppDomain) ; 
  var mgr = new ObjectManager     (null, ctx) ; 
  var si  = new SerializationInfo (e.GetType (), new FormatterConverter ()) ; 

  e.GetObjectData    (si, ctx)  ; 
  mgr.RegisterObject (e, 1, si) ; // prepare for SetObjectData 
  mgr.DoFixups       ()         ; // ObjectManager calls SetObjectData 

  // voila, e is unmodified save for _remoteStackTraceString 
} 

Obwohl es den Vorteil hat, dass es sich nur auf öffentliche Methoden stützt, hängt es auch von dem folgenden Ausnahmekonstruktor ab (den einige von Drittanbietern entwickelte Ausnahmen nicht implementieren):

protected Exception(
    SerializationInfo info,
    StreamingContext context
)

In meiner Situation musste ich den ersten Ansatz wählen, weil die Ausnahmen, die von einer Bibliothek eines Drittanbieters ausgelöst wurden, die ich verwendete, diesen Konstruktor nicht implementierten.

Answer 4

Wenn Sie throw ex werfen Sie im Wesentlichen eine neue Ausnahme und verpassen die ursprünglichen Stack-Trace-Informationen. throw ist die bevorzugte Methode.

Answer 5

Niemand hat den Unterschied zwischen ExceptionDispatchInfo.Capture( ex ).Throw() und eine einfache throw Hier ist sie also. Allerdings haben einige Leute das Problem bemerkt mit throw .

Die vollständige Art und Weise, eine abgefangene Ausnahme erneut auszulösen, ist die Verwendung von ExceptionDispatchInfo.Capture( ex ).Throw() (erst ab .Net 4.5 verfügbar).

Nachfolgend finden Sie die Fälle, die für die Prüfung dieser Frage erforderlich sind:

1.

void CallingMethod()
{
    //try
    {
        throw new Exception( "TEST" );
    }
    //catch
    {
    //    throw;
    }
}

2.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch( Exception ex )
    {
        ExceptionDispatchInfo.Capture( ex ).Throw();
        throw; // So the compiler doesn't complain about methods which don't either return or throw.
    }
}

3.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch
    {
        throw;
    }
}

4.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch( Exception ex )
    {
        throw new Exception( "RETHROW", ex );
    }
}

In den Fällen 1 und 2 erhalten Sie einen Stack-Trace, in dem die Quellcode-Zeilennummer für die CallingMethod Methode ist die Zeilennummer der throw new Exception( "TEST" ) Linie.

In Fall 3 erhalten Sie jedoch einen Stack-Trace, in dem die Quellcode-Zeilennummer für die CallingMethod Methode ist die Zeilennummer der throw anrufen. Das bedeutet, dass, wenn der throw new Exception( "TEST" ) Zeile von anderen Operationen umgeben ist, haben Sie keine Ahnung, bei welcher Zeilennummer die Ausnahme tatsächlich ausgelöst wurde.

Fall 4 ist ähnlich wie Fall 2, da die Zeilennummer der ursprünglichen Ausnahme erhalten bleibt, aber es handelt sich nicht um einen echten Rückruf, da der Typ der ursprünglichen Ausnahme geändert wird.