difference between throw and throw new Exception

Question

what is the difference between   try         catch  throw      and   try        catch Exception e   throw new Exception e message       Regardless that the second shows a message

User · Answer

None of the answers here show the difference, which could be helpful for folks struggling to understand the difference. Consider this sample code:

using System;
using System.Collections.Generic;

namespace ExceptionDemo
{
   class Program
   {
      static void Main(string[] args)
      {
         void fail()
         {
            (null as string).Trim();
         }

         void bareThrow()
         {
            try
            {
               fail();
            }
            catch (Exception e)
            {
               throw;
            }
         }

         void rethrow()
         {
            try
            {
               fail();
            }
            catch (Exception e)
            {
               throw e;
            }
         }

         void innerThrow()
         {
            try
            {
               fail();
            }
            catch (Exception e)
            {
               throw new Exception("outer", e);
            }
         }

         var cases = new Dictionary<string, Action>()
         {
            { "Bare Throw:", bareThrow },
            { "Rethrow", rethrow },
            { "Inner Throw", innerThrow }
         };

         foreach (var c in cases)
         {
            Console.WriteLine(c.Key);
            Console.WriteLine(new string('-', 40));
            try
            {
               c.Value();
            } catch (Exception e)
            {
               Console.WriteLine(e.ToString());
            }
         }
      }
   }
}

Which generates the following output:

Bare Throw:
----------------------------------------
System.NullReferenceException: Object reference not set to an instance of an object.
   at ExceptionDemo.Program.<Main>g__fail|0_0() in C:\...\ExceptionDemo\Program.cs:line 12
   at ExceptionDemo.Program.<>c.<Main>g__bareThrow|0_1() in C:\...\ExceptionDemo\Program.cs:line 19
   at ExceptionDemo.Program.Main(String[] args) in C:\...\ExceptionDemo\Program.cs:line 64

Rethrow
----------------------------------------
System.NullReferenceException: Object reference not set to an instance of an object.
   at ExceptionDemo.Program.<>c.<Main>g__rethrow|0_2() in C:\...\ExceptionDemo\Program.cs:line 35
   at ExceptionDemo.Program.Main(String[] args) in C:\...\ExceptionDemo\Program.cs:line 64

Inner Throw
----------------------------------------
System.Exception: outer ---> System.NullReferenceException: Object reference not set to an instance of an object.
   at ExceptionDemo.Program.<Main>g__fail|0_0() in C:\...\ExceptionDemo\Program.cs:line 12
   at ExceptionDemo.Program.<>c.<Main>g__innerThrow|0_3() in C:\...\ExceptionDemo\Program.cs:line 43
   --- End of inner exception stack trace ---
   at ExceptionDemo.Program.<>c.<Main>g__innerThrow|0_3() in C:\...\ExceptionDemo\Program.cs:line 47
   at ExceptionDemo.Program.Main(String[] args) in C:\...\ExceptionDemo\Program.cs:line 64

The bare throw, as indicated in the previous answers, clearly shows both the original line of code that failed (line 12) as well as the two other points active in the call stack when the exception occurred (lines 19 and 64).

The output of the re-throw case shows why it's a problem. When the exception is rethrown like this the exception won't include the original stack information. Note that only the throw e (line 35) and outermost call stack point (line 64) are included. It would be difficult to track down the fail() method as the source of the problem if you throw exceptions this way.

The last case (innerThrow) is most elaborate and includes more information than either of the above. Since we're instantiating a new exception we get the chance to add contextual information (the "outer" message, here but we can also add to the .Data dictionary on the new exception) as well as preserving all of the information in the original exception (including help links, data dictionary, etc.).

User · Answer

throw is for rethrowing a caught exception   This can be useful if you want to do something with the exception before passing it up the call chain   Using throw without any arguments preserves the call stack for debugging purposes

User · Answer

One other point that I didn t see anyone make   If you don t do anything in your catch    block  having a try   catch is pointless   I see this all the time   try        Code here   catch       throw      Or worse   try        Code here   catch Exception ex        throw ex      Worst yet   try        Code here   catch Exception ex        throw new System Exception ex Message

User · Answer

throw re-throws the caught exception  retaining the stack trace  while throw new Exception loses some of the details of the caught exception   You would normally use throw by itself to log an exception without fully handling it at that point   BlackWasp has a good article sufficiently titled Throwing Exceptions in C

User · Answer

Your second example will reset the exception s stack trace  The first most accurately preserves the origins of the exception  Also you ve unwrapped the original type which is key in knowing what actually went wrong    If the second is required for functionality - e g  To add extended info or re-wrap with special type such as a custom  HandleableException  then just be sure that the InnerException property is set too

User · Answer

Most important difference is that second expression erases type of exception  And exception type plays vital role in catching exceptions   public void MyMethod             both can throw IOException     try   foo      catch   throw        try   bar      catch E   throw new Exception E message               try       MyMethod       catch  IOException ex        Console WriteLine   Error with I O        1    catch  Exception ex        Console WriteLine   Other error           2      If foo   throws IOException   1  catch block will catch exception  But when bar   throws IOException  it will be converted to plain Exception ant won t be caught by  1  catch block

User · Answer

throw  rethrows the original exception and preserves its original stack trace  throw ex  throws the original exception but resets the stack trace  destroying all stack trace information until your catch block   NEVER write throw ex   throw new Exception ex Message   is even worse   It creates a brand new Exception instance  losing the original stack trace of the exception  as well as its type    eg  IOException   In addition  some exceptions hold additional information  eg  ArgumentException ParamName   throw new Exception ex Message    will destroy this information too  In certain cases  you may want to wrap all exceptions in a custom exception object  so that you can provide additional information about what the code was doing when the exception was thrown  To do this  define a new class that inherits Exception  add all four exception constructors  and optionally an additional constructor that takes an InnerException as well as additional information  and throw your new exception class  passing ex as the InnerException parameter   By passing the original InnerException  you preserve all of the original exception s properties  including the stack trace

User · Answer

If you want you can throw a new Exception  with the original one set as an inner exception

User · Answer

The first preserves the original stacktrace   try         catch          Do something      throw      The second allows you to change the type of the exception and or the message and other data   try         catch  Exception e        throw new BarException  Something broke         There s also a third way where you pass an inner exception   try         catch  FooException e        throw new BarException  foo   e        I d recommend using    the first if you want to do some cleanup in error situation without destroying information or adding information about the error  the third if you want to add more information about the error  the second if you want to hide information  from untrusted users

User · Answer

Throw  Rethrow the original exception and keep the exception type   Throw new exception    Rethrow the original exception type  and reset the exception stack trace  Throw ex  Reset the exception stack trace and reset the exception type

User · Answer

Throwing a new Exception blows away the current stack trace   throw  will retain the original stack trace and is almost always more useful  The exception to that rule is when you want to wrap the Exception in a custom Exception of your own  You should then do   catch Exception e        throw new CustomException customMessage  e

User · Answer

throw or throw ex  both are used to throw or rethrow the exception  when you just simply log the error information and don t want to send any information back to the caller you simply log the error in catch and leave  But incase you want to send some meaningful information about the exception to the caller you use throw or throw ex  Now the difference between throw and throw ex is that throw preserves the stack trace and other information but throw ex creates a new exception object and hence the original stack trace is lost   So when should we use throw and throw e  There are still a few situations in which you might want to rethrow an exception like to reset the call stack information  For example  if the method is in a library and you want to hide the details of the library from the calling code  you don   t necessarily want the call stack to include information about private methods within the library  In that case  you could catch exceptions in the library   s public methods and then rethrow them so that the call stack begins at those public methods

[c#] difference between throw and throw new Exception()

Examples related to c#