Gibt es einen Unterschied zwischen "throw" und "throw ex"?

Question

Es gibt bereits einige Beiträge, die nach dem Unterschied zwischen den beiden fragen.
(Warum muss ich das überhaupt erwähnen...)

Aber meine Frage unterscheidet sich insofern, als dass ich "throw ex" in einer anderen Fehler gottgleichen Behandlungsmethode aufrufe.

public class Program {
    public static void Main(string[] args) {
        try {
            // etwas
        } catch (Exception ex) {
            HandleException(ex);
        }
    }

    private static void HandleException(Exception ex) {
        if (ex is ThreadAbortException) {
            // dann ignorieren,
            return;
        }
        if (ex is ArgumentOutOfRangeException) { 
            // dann protokollieren,
            throw ex;
        }
        if (ex is InvalidOperationException) {
            // dann Nachricht anzeigen,
            throw ex;
        }
        // und so weiter.
    }
}

Wenn try & catch im Main verwendet wurden, würde ich throw; verwenden, um den Fehler erneut zu werfen. Aber im obigen vereinfachten Code durchlaufen alle Ausnahmen HandleException.

Hat throw ex; den gleichen Effekt wie das Aufrufen von throw, wenn es innerhalb von HandleException aufgerufen wird?

Answer 1

Ja, es gibt einen Unterschied.

• throw ex setzt den Stack-Trace zurück (so dass Ihre Fehler scheinbar von HandleException ausgehen würden)

• throw tut das nicht - der ursprüngliche Verursacher bleibt erhalten.

   static void Main(string[] args)
   {
       try
       {
           Method2();
       }
       catch (Exception ex)
       {
           Console.Write(ex.StackTrace.ToString());
           Console.ReadKey();
       }
   }
  
   private static void Method2()
   {
       try
       {
           Method1();
       }
       catch (Exception ex)
       {
           //throw ex setzt den Stack-Trace zurück, der von Method 1 stammt und gibt ihn an den Aufrufer (Main) weiter
           throw ex;
       }
   }
  
   private static void Method1()
   {
       try
       {
           throw new Exception("Innerhalb von Method1");
       }
       catch (Exception)
       {
           throw;
       }
   }

Answer 2

(Ich habe früher einen Beitrag gepostet, und @Marc Gravell hat mich korrigiert)

Hier ist eine Demonstration des Unterschieds:

static void Main(string[] args) {
    try {
        ThrowException1(); // Zeile 19
    } catch (Exception x) {
        Console.WriteLine("Ausnahme 1:");
        Console.WriteLine(x.StackTrace);
    }
    try {
        ThrowException2(); // Zeile 25
    } catch (Exception x) {
        Console.WriteLine("Ausnahme 2:");
        Console.WriteLine(x.StackTrace);
    }
}

private static void ThrowException1() {
    try {
        DivByZero(); // Zeile 34
    } catch {
        throw; // Zeile 36
    }
}
private static void ThrowException2() {
    try {
        DivByZero(); // Zeile 41
    } catch (Exception ex) {
        throw ex; // Zeile 43
    }
}

private static void DivByZero() {
    int x = 0;
    int y = 1 / x; // Zeile 49
}

und hier ist die Ausgabe:

Ausnahme 1:
   at UnitTester.Program.DivByZero() in \Dev\UnitTester\Program.cs:line 49
   at UnitTester.Program.ThrowException1() in \Dev\UnitTester\Program.cs:line 36
   at UnitTester.Program.TestExceptions() in \Dev\UnitTester\Program.cs:line 19

Ausnahme 2:
   at UnitTester.Program.ThrowException2() in \Dev\UnitTester\Program.cs:line 43
   at UnitTester.Program.TestExceptions() in \Dev\UnitTester\Program.cs:line 25

Sie können sehen, dass bei Ausnahme 1 der Stack-Trace bis zur Methode DivByZero() zurückverfolgt wird, während dies bei Ausnahme 2 nicht der Fall ist.

Beachten Sie jedoch, dass die Zeilennummer, die in ThrowException1() und ThrowException2() angezeigt wird, die Zeilennummer der throw-Anweisung ist, nicht die Zeilennummer des Aufrufs von DivByZero() ist, was vermutlich Sinn macht, wenn ich darüber nachdenke...

Ausgabe im Release-Modus

Ausnahme 1:

at ConsoleAppBasics.Program.ThrowException1()
at ConsoleAppBasics.Program.Main(String[] args)

Ausnahme 2:

at ConsoleAppBasics.Program.ThrowException2()
at ConsoleAppBasics.Program.Main(String[] args)

Wird der ursprüngliche Stack-Trace nur im Debug-Modus beibehalten?

Answer 3

Throw bewahrt den Stack-Trace. Angenommen, Source1 wirft Error1, wird es von Source2 abgefangen und Source2 sagt throw, dann wird der Fehler von Source1 + der Fehler von Source2 im Stack-Trace verfügbar sein.

Throw ex bewahrt den Stack-Trace nicht. Alle Fehler von Source1 werden also gelöscht und nur der Fehler von Source2 wird an den Client gesendet.

Manchmal sind Dinge durch bloßes Lesen nicht klar, daher empfehle ich, dieses Video anzusehen, um mehr Klarheit zu erhalten, Throw vs Throw ex in C#.

Answer 4

Die anderen Antworten sind völlig korrekt, aber diese Antwort enthält meiner Meinung nach einige zusätzliche Details.

Betrachten Sie dieses Beispiel:

using System;

static class Program {
  static void Main() {
    try {
      ThrowTest();
    } catch (Exception e) {
      Console.WriteLine("Ihr Stack-Trace:");
      Console.WriteLine(e.StackTrace);
      Console.WriteLine();
      if (e.InnerException == null) {
        Console.WriteLine("Keine innere Ausnahme.");
      } else {
        Console.WriteLine("Stack-Trace Ihrer inneren Ausnahme:");
        Console.WriteLine(e.InnerException.StackTrace);
      }
    }
  }

  static void ThrowTest() {
    decimal a = 1m;
    decimal b = 0m;
    try {
      Mult(a, b);  // Zeile 34
      Div(a, b);   // Zeile 35
      Mult(b, a);  // Zeile 36
      Div(b, a);   // Zeile 37
    } catch (ArithmeticException arithExc) {
      Console.WriteLine("Behandlung einer {0}.", arithExc.GetType().Name);

      //   entweder auskommentieren
      //throw arithExc;
      //   oder
      //throw;
      //   oder
      //throw new Exception("Wir haben Ihre Ausnahme behandelt und verpackt", arithExc);
    }
  }

  static void Mult(decimal x, decimal y) {
    decimal.Multiply(x, y);
  }
  static void Div(decimal x, decimal y) {
    decimal.Divide(x, y);
  }
}

Wenn Sie die Zeile throw arithExc; auskommentieren, lautet Ihre Ausgabe wie folgt:

Behandlung einer DivideByZeroException.
Ihr Stack-Trace:
   bei Program.ThrowTest() in c:\somepath\Program.cs: Zeile 44
   bei Program.Main() in c:\somepath\Program.cs: Zeile 9

Keine innere Ausnahme.

Sie haben sicherlich Informationen darüber verloren, wo genau diese Ausnahme aufgetreten ist. Wenn Sie stattdessen die Zeile throw; verwenden, erhalten Sie folgendes:

Behandlung einer DivideByZeroException.
Ihr Stack-Trace:
   bei System.Decimal.FCallDivide(Decimal& d1, Decimal& d2)
   bei System.Decimal.Divide(Decimal d1, Decimal d2)
   bei Program.Div(Decimal x, Decimal y) in c:\somepath\Program.cs: Zeile 58
   bei Program.ThrowTest() in c:\somepath\Program.cs: Zeile 46
   bei Program.Main() in c:\somepath\Program.cs: Zeile 9

Keine innere Ausnahme.

Dies ist wesentlich besser, denn jetzt sehen Sie, dass es die Methode Program.Div war, die Probleme verursacht hat. Es ist jedoch immer noch schwer zu erkennen, ob dieses Problem von Zeile 35 oder Zeile 37 im try-Block kommt.

Wenn Sie die dritte Alternative verwenden und in eine äußere Ausnahme verpacken, verlieren Sie keine Informationen:

Behandlung einer DivideByZeroException.
Ihr Stack-Trace:
   bei Program.ThrowTest() in c:\somepath\Program.cs: Zeile 48
   bei Program.Main() in c:\somepath\Program.cs: Zeile 9

Stack-Trace Ihrer inneren Ausnahme:
   bei System.Decimal.FCallDivide(Decimal& d1, Decimal& d2)
   bei System.Decimal.Divide(Decimal d1, Decimal d2)
   bei Program.Div(Decimal x, Decimal y) in c:\somepath\Program.cs: Zeile 58
   bei Program.ThrowTest() in c:\somepath\Program.cs: Zeile 35

Insbesondere können Sie sehen, dass es Zeile 35 ist, die zu dem Problem führt. Dies erfordert jedoch, dass die Leute die InnerException durchsuchen, und es fühlt sich etwas indirekt an, innere Ausnahmen in einfachen Fällen zu verwenden.

In diesem Blog-Beitrag erhalten sie die Zeilennummer (Zeile des try-Blocks), indem sie (über Reflektion) die internal Instanzmethode InternalPreserveStackTrace() auf dem Exception-Objekt aufrufen. Aber es ist nicht schön, so Reflektion zu verwenden (das .NET-Framework könnte seine internal-Member eines Tages ohne Vorwarnung ändern).

Answer 5

Wenn Sie throw ex verwenden, wird diese geworfene Ausnahme zur "ursprünglichen" Ausnahme. Daher werden alle vorherigen Stack-Traces nicht vorhanden sein.

Wenn Sie throw verwenden, geht die Ausnahme einfach den ganzen Weg nach unten und Sie erhalten den vollständigen Stack-Trace.