We generally use exception and stack trace for tracking down to the problem in our code. But a lots of the time, in case you are not using proper way to throw exceptions then it might make difficult to narrow down the problem. Whenever we throw an exception; it is recorded into the exception stack trace.
Let understand this with an example. Consider the below console application:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
using System; using System.Text; namespace ExceptionTest { class Program { static void Main(string[] args) { new ExceptionTester().FirstCall(); } } public class ExceptionTester { public void FirstCall() { try { SecondCall(); } catch(Exception ex) { Console.WriteLine(ex.StackTrace); } } public void SecondCall() { try { ThirdCall(); } catch { throw; } } public void ThirdCall() { try { ForthCall(); } catch { throw; } } public void ForthCall() { int d = 0; int x = 10 / d; } } } |
You may see the that the initially the FirstCall() method is called which internally calling SecondCall() > ThirdCall() > ForthCall() and the ForthCall is generating System.DivideByZeroException exception. Each function is throwing the exception by using throw keyword. Output of the above program will be:
By looking at above stack trace you could easily track down the root cause of the problem. Method ForthCall() is the culprit.
Do not Throw Same Exception
A lots of time its common mistake to throw same exception again instead of re-throwing it. Look at below bad practice of coding:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
using System; using System.Text; namespace ExceptionTest { class Program { static void Main(string[] args) { new ExceptionTester().FirstCall(); } } public class ExceptionTester { public void FirstCall() { try { SecondCall(); } catch(Exception ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); } } public void SecondCall() { try { ThirdCall(); } catch(Exception ex) { throw ex; } } public void ThirdCall() { try { ForthCall(); } catch (Exception ex) { throw ex; } } public void ForthCall() { int d = 0; int x = 10 / d; } } } |
“throw ex;” is basically throwing the same exception again instead of re-throwing the original exception. Because of this the all exception stack trace information is lost till this point and stack started to build again. The output of above program will be:
You can see we can only see methods SecondCall() and FirstCall() in the exception stack. Final conclusion of this whole article is to be careful while throwing exception.
