Home
C#
throw Keyword Examples
Updated Aug 4, 2025
Dot Net Perls
Exceptionint.ParseTernary

Throw

The throw-keyword in C# generates (or translates) exceptions. By using a throw-statement inside a catch block, we can change the resulting exception.

Notes, throw

We can throw a new exception. The throw-statement is versatile—throw is a statement, but also a special kind of expression.

Example

We first look at 3 methods A, B, and C that use the throw-statement in different ways. Method A uses a throw0statement with no argument.

Info The code in method A can be thought of as a rethrow—it throws the same exception already being handled.
Next Method B throws a named exception variable. This is not a rethrow—it throws the same exception but changes the stack trace.
Also We can collect information about the exception if needed. Method C creates a new exception.
Tip We can use a throw-statement in this way to implement custom error conditions.
using System;

class Program
{
    static void Main()
    {
        // Call method A, method B, and method C.
        // ... Comment out the first 1-2 method invocations.
        try
        {
            A();
            B();
            C(null);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }

    static void A()
    {
        // Rethrow syntax.
        try
        {
            int value = 1 / int.Parse("0");
        }
        catch
        {
            throw;
        }
    }

    static void B()
    {
        // Filtering exception types.
        try
        {
            int value = 1 / int.Parse("0");
        }
        catch (DivideByZeroException ex)
        {
            throw ex;
        }
    }

    static void C(string value)
    {
        // Generate new exception.
        if (value == null)
        {
            throw new ArgumentNullException("value");
        }
    }
}
System.DivideByZeroException: Attempted to divide by zero. System.DivideByZeroException: Attempted to divide by zero. System.ArgumentNullException: Value cannot be null. Parameter name: value

Rethrow

Next we examine rethrows in the C# language. A rethrow must use a throw-statement with no argument. If you use throw ex, then the TargetSite and StackTrace are changed.

Detail In this program, X() uses a rethrow statement. And Y() uses a throw ex statement.
Result We see in the results that when a rethrow is used, the exception TargetSite is in StringToNumber—an internal method of int.Parse.
But When a throw ex is used, as in Y(), the exception's TargetSite was modified to the current method Y().
using System;

class Program
{
    static void Main()
    {
        try
        {
            X();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.TargetSite);
        }

        try
        {
            Y();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.TargetSite);
        }
    }

    static void X()
    {
        try
        {
            int.Parse("?");
        }
        catch (Exception)
        {
            throw; // [Rethrow construct]
        }
    }

    static void Y()
    {
        try
        {
            int.Parse("?");
        }
        catch (Exception ex)
        {
            throw ex; // [Throw captured ex variable]
        }
    }
}
Void StringToNumber(System.String, ...) Void Y()

Throw expression

Throw is usually used as a statement. But in some places, it can be used as an expression. We can use throw as part of a null-coalescing statement.

Here Consider the Test() method. If its argument is null, a new ArgumentException is thrown as part of the null-coalescing statement.
using System;

class Program
{
    static void Test(string argument)
    {
        // Use null coalescing operator with throw expression.
        // ... If argument is null, throw.
        var value = argument ?? throw new ArgumentException("Bad argument");
        Console.WriteLine("HERE");
    }

    static void Main()
    {
        Test("bird");
        Test(null);
    }
}
HERE Unhandled Exception: System.ArgumentException: Bad argument at Program.Test(String argument) in c:\users\...Program.cs:line 9 at Program.Main() in c:\users\...Program.cs:line 16

Throw, ternary expression

A throw-expression can only be used in certain places in programs—not everywhere. We can use a throw-expression as part of a ternary statement.

Here The string's length is tested. If it has fewer than 10 characters, an Exception is thrown as part of the ternary.
using System;

class Program
{
    static void Main()
    {
        string test = "bird";
        // Throw can be used in ternary.
        char tenth = test.Length >= 10 ?
            test[9] :
            throw new Exception("Not ten characters");
        // Not reached.
        Console.WriteLine(tenth);
    }
}
Unhandled Exception: System.Exception: Not ten characters at Program.Main() in c:\users\...Program.cs:line 9

A review

The exception handling mechanism exploits an alternative control pathway. The throw-statement provides the ability to rethrow an exception or generate a new one.

We can use throw as a statement, or an expression in some places in our programs. Though the syntax is confusing at first, it becomes easier to use with familiarity.

Dot Net Perls is a collection of pages with code examples, which are updated to stay current. Programming is an art, and it can be learned from examples.
Donate to this site to help offset the costs of running the server. Sites like this will cease to exist if there is no financial support for them.
Sam Allen is passionate about computer languages, and he maintains 100% of the material available on this website. He hopes it makes the world a nicer place.
This page was last updated on Aug 4, 2025 (edit).
Home
Changes
© 2007-2025 Sam Allen