Throw vs throw ex in C#: Key Differences and When to Use Each

In C#, throw rethrows the current exception preserving the original stack trace, while throw ex throws the caught exception as new, resetting the stack trace. Use throw to keep debugging info intact and throw ex if you want to reset the stack trace (usually not recommended).

Quick Comparison

This table summarizes the key differences between throw and throw ex in C#.

Aspect	throw	throw ex
Stack Trace	Preserves original stack trace	Resets stack trace to current throw point
Usage	Rethrows current exception	Throws caught exception as new
Debugging	Easier to trace original error	Harder to trace original error
Common Practice	Preferred for rethrowing	Generally discouraged
Effect on Exception Object	No change	Stack trace overwritten

Key Differences

The main difference between throw and throw ex lies in how they handle the exception's stack trace. Using throw alone inside a catch block rethrows the current exception without altering its stack trace. This means the original error location is preserved, which helps developers understand where the exception first occurred.

On the other hand, throw ex throws the caught exception as if it is a new exception from the current point in code. This resets the stack trace to the line where throw ex is called, losing the original error context. This makes debugging harder because the stack trace no longer shows the true source of the problem.

Because of this, throw is generally preferred when you want to propagate exceptions up the call stack while keeping full debugging information intact. Using throw ex is usually discouraged unless you explicitly want to reset the stack trace for some reason.

Code Comparison

This example shows how throw rethrows an exception preserving the original stack trace.

csharp

using System;

class Program
{
    static void Main()
    {
        try
        {
            CauseError();
        }
        catch (Exception ex)
        {
            Console.WriteLine("Caught in Main, rethrowing with throw:");
            try
            {
                throw; // rethrow preserves stack trace
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
    }

    static void CauseError()
    {
        throw new InvalidOperationException("Original error");
    }
}

Output

Caught in Main, rethrowing with throw:
System.InvalidOperationException: Original error
   at Program.CauseError() in Program.cs:line 20
   at Program.Main() in Program.cs:line 8

throw ex Equivalent

This example shows how throw ex resets the stack trace to the throw point.

csharp

using System;

class Program
{
    static void Main()
    {
        try
        {
            CauseError();
        }
        catch (Exception ex)
        {
            Console.WriteLine("Caught in Main, rethrowing with throw ex:");
            try
            {
                throw ex; // resets stack trace
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
    }

    static void CauseError()
    {
        throw new InvalidOperationException("Original error");
    }
}

Output

Caught in Main, rethrowing with throw ex:
System.InvalidOperationException: Original error
   at Program.Main() in Program.cs:line 13

When to Use Which

Choose throw when you want to rethrow an exception and keep the original stack trace intact for easier debugging. This is the best practice in most cases because it preserves the full error context.

Choose throw ex only if you have a specific reason to reset the stack trace, such as when you want to hide the original error location or wrap the exception differently (though wrapping is better done with throw new Exception(..., ex)).

In general, avoid throw ex to prevent losing valuable debugging information.

Key Takeaways

throw preserves the original exception stack trace and is preferred for rethrowing.

throw ex resets the stack trace to the current throw point, losing original error context.

Use throw inside catch blocks to keep debugging easier and more accurate.

Avoid throw ex unless you explicitly want to reset the stack trace.

For wrapping exceptions, use throw new Exception(message, ex) instead of throw ex.