“throw”和“throw ex”之间有区别吗?

时间:2009-04-08 14:22:13

标签: c# .net exception exception-handling

有些帖子询问这两者之间的区别是什么。
(为什么我甚至要提到这个...)

但我的问题不同,我在另一个错误类似神的处理方法中称之为“抛出前”。

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

    private static void HandleException(Exception ex) {
        if (ex is ThreadAbortException) {
            // ignore then,
            return;
        }
        if (ex is ArgumentOutOfRangeException) { 
            // Log then,
            throw ex;
        }
        if (ex is InvalidOperationException) {
            // Show message then,
            throw ex;
        }
        // and so on.
    }
}

如果在try & catch中使用了Main,那么我会使用throw;来重新抛出错误。 但在上面简化的代码中,所有异常都通过HandleException

throw ex;内调用时,throw与调用HandleException具有相同的效果吗?

12 个答案:

答案 0 :(得分:619)

是的,有区别;

  • throw ex重置堆栈跟踪(因此您的错误似乎来自HandleException
  • throw没有 - 原始罪犯将被保留。

    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 resets the stack trace Coming from Method 1 and propogates it to the caller(Main)
            throw ex;
        }
    }
    
    private static void Method1()
    {
        try
        {
            throw new Exception("Inside Method1");
        }
        catch (Exception)
        {
            throw;
        }
    }
    

答案 1 :(得分:89)

(我之前发过,@ Marc Gravell纠正了我)

以下是差异的演示:

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

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

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

这是输出:

Exception 1:
   at UnitTester.Program.DivByZero() in <snip>\Dev\UnitTester\Program.cs:line 49
   at UnitTester.Program.ThrowException1() in <snip>\Dev\UnitTester\Program.cs:line 36
   at UnitTester.Program.TestExceptions() in <snip>\Dev\UnitTester\Program.cs:line 19

Exception 2:
   at UnitTester.Program.ThrowException2() in <snip>\Dev\UnitTester\Program.cs:line 43
   at UnitTester.Program.TestExceptions() in <snip>\Dev\UnitTester\Program.cs:line 25

您可以看到,在异常1中,堆栈跟踪返回到DivByZero()方法,而在异常2中则没有。

请注意,ThrowException1()ThrowException2()中显示的行号是throw语句的行号,不是的行号对DivByZero()的调用,这可能是有道理的,因为我现在考虑了一下......

在发布模式下输出

例外1:

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

例外2:

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

它是否仅在调试模式下维护原始stackTrace?

答案 2 :(得分:37)

其他答案完全正确,但我认为这个答案提供了一些额外的答案。

考虑这个例子:

using System;

static class Program {
  static void Main() {
    try {
      ThrowTest();
    } catch (Exception e) {
      Console.WriteLine("Your stack trace:");
      Console.WriteLine(e.StackTrace);
      Console.WriteLine();
      if (e.InnerException == null) {
        Console.WriteLine("No inner exception.");
      } else {
        Console.WriteLine("Stack trace of your inner exception:");
        Console.WriteLine(e.InnerException.StackTrace);
      }
    }
  }

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

      //   uncomment EITHER
      //throw arithExc;
      //   OR
      //throw;
      //   OR
      //throw new Exception("We handled and wrapped your exception", arithExc);
    }
  }

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

如果取消注释throw arithExc;行,则输出为:

Handling a DivideByZeroException.
Your stack trace:
   at Program.ThrowTest() in c:\somepath\Program.cs:line 44
   at Program.Main() in c:\somepath\Program.cs:line 9

No inner exception.

当然,您丢失了有关该异常发生位置的信息。如果您使用throw;行,则可以获得:

Handling a DivideByZeroException.
Your stack trace:
   at System.Decimal.FCallDivide(Decimal& d1, Decimal& d2)
   at System.Decimal.Divide(Decimal d1, Decimal d2)
   at Program.Div(Decimal x, Decimal y) in c:\somepath\Program.cs:line 58
   at Program.ThrowTest() in c:\somepath\Program.cs:line 46
   at Program.Main() in c:\somepath\Program.cs:line 9

No inner exception.

这样做要好得多,因为现在您看到Program.Div方法导致了您的问题。但是仍然很难看出这个问题是来自try区块中的第35行还是第37行。

如果您使用第三个替代方法,包装在外部异常中,则不会丢失任何信息:

Handling a DivideByZeroException.
Your stack trace:
   at Program.ThrowTest() in c:\somepath\Program.cs:line 48
   at Program.Main() in c:\somepath\Program.cs:line 9

Stack trace of your inner exception:
   at System.Decimal.FCallDivide(Decimal& d1, Decimal& d2)
   at System.Decimal.Divide(Decimal d1, Decimal d2)
   at Program.Div(Decimal x, Decimal y) in c:\somepath\Program.cs:line 58
   at Program.ThrowTest() in c:\somepath\Program.cs:line 35

特别是你可以看到导致问题的第35行。但是,这需要人们搜索InnerException,在简单的情况下使用内部异常会感觉有点间接。

this blog post中,他们通过调用(通过反射)internal对象上的InternalPreserveStackTrace() intance方法Exception来保留行号(try块的行)。但是使用这样的反射并不好(.NET Framework可能会在某天没有警告的情况下更改他们的internal成员。)

答案 3 :(得分:17)

Throw 保留堆栈跟踪。所以假设 Source1 抛出 Error1 ,它被 Source2 捕获,而 Source2 说 throw 那么 Source1 Error + Source2 Error 将在堆栈跟踪中可用。

Throw ex 不保留堆栈跟踪。所以Source1的所有错误都会被清除,只有Source2的错误会发送到客户端。

有时只是看东西不清楚,建议观看此视频演示以获得更清晰的信息,Throw vs Throw ex in C#

Throw vs Throw ex

答案 4 :(得分:5)

让我们理解throw和throw ex之间的区别。我听说在很多.net采访中都会被问到这个常见问题。

为了概述这两个术语,throw和throw ex都用于了解异常发生的位置。抛出ex重写异常的堆栈跟踪,而不管实际抛出的位置。

让我们通过一个例子来理解。

让我们先了解一下。

static void Main(string[] args) {
    try {
        M1();
    } catch (Exception ex) {
        Console.WriteLine(" -----------------Stack Trace Hierarchy -----------------");
        Console.WriteLine(ex.StackTrace.ToString());
        Console.WriteLine(" ---------------- Method Name / Target Site -------------- ");
        Console.WriteLine(ex.TargetSite.ToString());
    }
    Console.ReadKey();
}

static void M1() {
    try {
        M2();
    } catch (Exception ex) {
        throw;
    };
}

static void M2() {
    throw new DivideByZeroException();
}

以上输出如下。

显示完整的层次结构和方法名称,实际上抛出了异常..它是M2 - &gt; M2。以及行号

enter image description here

其次..让我们通过throw ex理解。只需在M2方法catch块中用throw ex替换throw。如下。

enter image description here

throw ex code的输出如下..

enter image description here

您可以看到输出中的差异.stone ex忽略所有先前的层次结构,并使用line / method重置堆栈跟踪,其中写入了throw ex。

答案 5 :(得分:4)

不,这会导致异常具有不同的堆栈跟踪。仅在throw处理程序中使用catch而没有任何异常对象将使堆栈跟踪保持不变。

您可能希望从HandleException返回一个布尔值,无论是否重新抛出异常。

答案 6 :(得分:4)

当您抛出ex时,抛出的异常将成为“原始”异常。所以之前的所有堆栈跟踪都不存在。

如果你做了抛出,那么异常只是沿着行进行,你将获得完整的堆栈跟踪。

答案 7 :(得分:3)

MSDN代表

  

一旦抛出异常,它携带的部分信息就是   堆栈跟踪。堆栈跟踪是方法调用层次结构的列表   从以抛出异常并以...结尾的方法开始   捕获异常的方法。如果重新抛出异常   在throw语句中指定异常,堆栈跟踪是   在当前方法和之间的方法调用列表中重新启动   抛出异常的原始方法和当前方法是   丢失。要保留原始堆栈跟踪信息,例外,   使用throw语句而不指定异常。

答案 8 :(得分:1)

请看这里:http://blog-mstechnology.blogspot.de/2010/06/throw-vs-throw-ex.html

<强>投掷

try 
{
    // do some operation that can fail
}
catch (Exception ex)
{
    // do some local cleanup
    throw;
}

它使用Exception保存堆栈信息

这被称为&#34; Rethrow&#34;

如果想要抛出新的异常,

throw new ApplicationException("operation failed!");

抛出

try
{
    // do some operation that can fail
}
catch (Exception ex)
{
    // do some local cleanup
    throw ex;
}

它不会发送带有异常的堆栈信息

这称为&#34;打破堆栈&#34;

如果想要抛出新的异常,

throw new ApplicationException("operation failed!",ex);

答案 9 :(得分:0)

为了给您一个不同的视角,如果您向客户端提供API并且想要为内部库提供详细的堆栈跟踪信息,则使用throw特别有用。通过在这里使用throw,我获得了File.Delete的System.IO.File库的堆栈跟踪。如果我使用throw ex,那么该信息将不会传递给我的处理程序。

static void Main(string[] args) {            
   Method1();            
}

static void Method1() {
    try {
        Method2();
    } catch (Exception ex) {
        Console.WriteLine("Exception in Method1");             
    }
}

static void Method2() {
    try {
        Method3();
    } catch (Exception ex) {
        Console.WriteLine("Exception in Method2");
        Console.WriteLine(ex.TargetSite);
        Console.WriteLine(ex.StackTrace);
        Console.WriteLine(ex.GetType().ToString());
    }
}

static void Method3() {
    Method4();
}

static void Method4() {
    try {
        System.IO.File.Delete("");
    } catch (Exception ex) {
        // Displays entire stack trace into the .NET 
        // or custom library to Method2() where exception handled
        // If you want to be able to get the most verbose stack trace
        // into the internals of the library you're calling
        throw;                
        // throw ex;
        // Display the stack trace from Method4() to Method2() where exception handled
    }
}

答案 10 :(得分:0)

最好使用throw而不是throw ex

抛出ex重置原始堆栈跟踪,而找不到先前的堆栈跟踪。

如果使用throw,我们将获得完整的堆栈跟踪。

答案 11 :(得分:-1)

int a = 0;
try {
    int x = 4;
    int y ;
    try {
        y = x / a;
    } catch (Exception e) {
        Console.WriteLine("inner ex");
        //throw;   // Line 1
        //throw e;   // Line 2
        //throw new Exception("devide by 0");  // Line 3
    }
} catch (Exception ex) {
    Console.WriteLine(ex);
    throw ex;
}
  1. 如果所有第1,第2和第3行都被评论 - 输出 - 内部前

  2. 如果所有第2行和第3行都被评论 - 输出 - 内部前     System.DevideByZeroException:{&#34;尝试除以零。&#34;} ---------

  3. 如果所有第1行和第2行都被评论 - 输出 - 内部前     System.Exception:devide by 0 ----

  4. 如果所有第1行和第3行都被评论 - 输出 - 内部前     System.DevideByZeroException:{&#34;尝试除以零。&#34;} ---------

  5. 如果抛出ex;

    ,将重置

    和StackTrace