有些帖子询问这两者之间的区别是什么。
(为什么我还要提这个...)
但我的问题是不同的,我称之为“抛出ex”在另一个错误的神像处理方法。
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.
}
}
如果在Main
中使用了try & catch
,那么我会使用throw;
重新抛出错误。 但在上面简化的代码中,所有异常都通过HandleException
throw ex;
在HandleException
调用时,与调用throw
具有相同的效果?
#1楼
其他答案完全正确,但我认为这个答案提供了一些额外的答案。
考虑这个例子:
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
,并且在简单的情况下使用内部异常感觉有点间接。
在这篇博客文章中,他们通过调用(通过反射) Exception
对象上的internal
intance方法InternalPreserveStackTrace()
来保留行号(try块的行)。 但是使用这样的反射并不好(.NET Framework可能会在某天没有警告的情况下更改其internal
成员)。
#2楼
请看这里: 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保留堆栈信息
这被称为“Rethrow”
如果想抛出新的异常,
throw new ApplicationException("operation failed!");
扔前 :
try
{
// do some operation that can fail
}
catch (Exception ex)
{
// do some local cleanup
throw ex;
}
它不会发送带有异常的堆栈信息
这被称为“打破堆栈”
如果想抛出新的异常,
throw new ApplicationException("operation failed!",ex);
#3楼
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,第2和第3行都被注释 - 输出 - 内部前
如果所有第2行和第3行都被注释 - 输出 - 内部ex System.DevideByZeroException:{“试图除以零。”} ---------
如果所有第1行和第2行都被注释 - 输出 - 内部ex System.Exception:devide by 0 ----
如果所有第1行和第3行都被注释 - 输出 - 内部ex System.DevideByZeroException:{“试图除以零。”} ---------
如果是throw,则会重置StackTrace;
#4楼
为了给您一个不同的视角,如果您向客户端提供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
}
}
#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 - > M2。 以及行号
其次..让我们通过throw ex了解。 只需在M2方法catch块中用throw ex替换throw。 如下。
throw ex代码的输出如下。
您可以看到输出中的差异.stone ex忽略所有先前的层次结构,并使用行/方法重置堆栈跟踪,其中写入了throw ex。
#6楼
MSDN代表 :
抛出异常后,它携带的部分信息就是堆栈跟踪。 堆栈跟踪是方法调用层次结构的列表,该方法调用层次结构以抛出异常的方法开始,并以捕获异常的方法结束。 如果通过在throw语句中指定异常来重新抛出异常,则会在当前方法重新启动堆栈跟踪,并且抛出异常的原始方法与当前方法之间的方法调用列表将丢失。 要保留包含异常的原始堆栈跟踪信息,请使用throw语句而不指定异常。
#7楼
是,有一点不同;
-
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; } }
#8楼
不,这将导致异常具有不同的堆栈跟踪。 只使用catch
处理程序中没有任何异常对象的throw
将使堆栈跟踪保持不变。
您可能希望从HandleException返回一个布尔值,无论是否重新抛出异常。
#9楼
抛出ex时,抛出的异常变为“原始”异常。 所以以前的所有堆栈跟踪都不会存在。
如果你做了抛出,那么异常只是在线上 ,你将获得完整的堆栈跟踪。
#10楼
(我之前发过,@ 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?