C# 使用throw;throw ex;和 throw new Exception();抛异常区别与建议 ...

之前，在使用异常捕获语句try...catch...throw语句时，一直没太留意几种用法的区别，前几天调试程序时发展找不到异常根源，无意中了解到几种使用方法是有区别的。总结如下：
我们都知道，C#中使用throw和throw ex抛出异常，但二者是有区别的。
在C#中推荐使用throw；来抛出异常；throw ex；会将到现在为止的所有信息清空，认为你catch到的异常已经被处理了，只不过处理过程中又抛出新的异常，从而找不到真正的错误源。
throw new Exception()包装一个异常，把内部异常Exception也抛出，这样抛出的异常是最全面详细的异常。
 
throw的用法主要有以下几种：
第一种（不推荐使用，可惜很多人都一直这么用的），这样适用会吃掉原始异常点，重置堆栈中的异常起始点：

1. try
2. {
3. }
4. catch (Exception ex)
5. {
6.     throw ex;

复制代码

第二种，可追溯到原始异常点，不过编译器会警告，定义的ex未有使用：

1. try
2. {
3. }
4. catch (Exception ex)
5. {
6.     throw;

复制代码

第三种，不带异常参数的，这个同第二种其实一样，可捕获所有类型的异常，IDE不会告警：

1. try
2. {
3. }
4. catch
5. {
6.     throw;
7. }

复制代码

第四种：经过对异常重新包装，但是会保留原始异常点信息。推荐使用。

1. try
2. {
3. }
4. catch (Exception ex)
5. {
6.     throw new Exception("经过进一步包装的异常", ex);
7. }

复制代码

下面举例测试:

1. 1 using System;
2. 2 using System.Collections.Generic;
3. 3 using System.Text;
4. 4
5. 5 namespace Api.Service.Common
6. 6 {
7. 7     public class ExceptionClass
8. 8     {
9. 9         /// <summary>
10. 10         /// 抛出异常方法
11. 11         /// </summary>
12. 12         public void ExceptionThrow1()
13. 13         {
14. 14             try
15. 15             {
16. 16                 // 调用原始异常抛出方法来抛出异常
17. 17                 this.ExceptionMethod();
18. 18             }
19. 19             catch (Exception ex)
20. 20             {
21. 21                 throw ex;
22. 22             }
23. 23         }
24. 24
25. 25         /// <summary>
26. 26         /// 抛出异常方法1
27. 27         /// </summary>
28. 28         public void ExceptionThrow2()
29. 29         {
30. 30             try
31. 31             {
32. 32                 this.ExceptionMethod();
33. 33             }
34. 34             catch (Exception ex)
35. 35             {
36. 36                 throw;
37. 37             }
38. 38         }
39. 39
40. 40         /// <summary>
41. 41         /// 抛出异常方法2
42. 42         /// </summary>
43. 43         public void ExceptionThrow3()
44. 44         {
45. 45             try
46. 46             {
47. 47                 this.ExceptionMethod();
48. 48             }
49. 49             catch
50. 50             {
51. 51                 throw;
52. 52             }
53. 53         }
54. 54
55. 55         /// <summary>
56. 56         /// 抛出异常方法3
57. 57         /// </summary>
58. 58         public void ExceptionThrow4()
59. 59         {
60. 60             try
61. 61             {
62. 62                 this.ExceptionMethod();
63. 63             }
64. 64             catch (Exception ex)
65. 65             {
66. 66                 throw new Exception("经过进一步包装的异常", ex);
67. 67             }
68. 68         }
69. 69
70. 70         /// <summary>
71. 71         /// 原始异常抛出方法
72. 72         /// </summary>
73. 73         private void ExceptionMethod()
74. 74         {
75. 75             throw new DivideByZeroException();
76. 76         }
77. 77     }
78. 78 }

复制代码

1. 　　　　　　　ExceptionClass exceptionClass = new ExceptionClass();
2.             try
3.             {
4.                 exceptionClass.ExceptionThrow1();
5.             }
6.             catch (Exception ex)
7.             {
8.                 Console.WriteLine(ex.ToString());
9.             }
10.             Console.WriteLine("分割线--------------------------------------");
11.             try
12.             {
13.                 exceptionClass.ExceptionThrow2();
14.             }
15.             catch (Exception ex)
16.             {
17.                 Console.WriteLine(ex.ToString());
18.             }
19.             Console.WriteLine("分割线--------------------------------------");
20.             try
21.             {
22.                 exceptionClass.ExceptionThrow3();
23.             }
24.             catch (Exception ex)
25.             {
26.                 Console.WriteLine(ex.ToString());
27.             }
28.             Console.WriteLine("分割线--------------------------------------");
29.             try
30.             {
31.                 exceptionClass.ExceptionThrow4();
32.             }
33.             catch (Exception ex)
34.             {
35.                 Console.WriteLine(ex.ToString());
36.             }

复制代码

举例结果:

 
 我们可以明显看出new Exception()自己包装的异常比较详细，能找到异常的跟踪，其次是throw  都可以找到异常源。
throw ex;会把异常吞掉，抛出新的异常，这样会让开发人员找不到异常源。
推荐使用new Excetion()也就是第四种方式。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！