C# - Throw keyword

Throw Keyword in C#

Introduction to C# Throw Keyword

The C# throw keyword plays a critical role in C# exception handling. In modern software development using the C# programming language, handling runtime errors properly is essential for building secure, stable, and scalable applications. The throw statement in C# is used to explicitly raise exceptions during program execution. It allows developers to create custom error scenarios and control the flow of execution when something unexpected occurs.

This comprehensive guide explains everything you need to know about the throw keyword in C#, including syntax, working mechanism, rethrowing exceptions, custom exceptions, best practices, and real-world examples.

What is the Throw Keyword in C#?

The throw keyword in C# is used to signal that an exceptional condition has occurred. When a throw statement is executed, it interrupts the normal flow of the program and transfers control to the nearest matching catch block.

In simple terms, the throw statement tells the runtime:

• An error has occurred
• Stop normal execution
• Look for an appropriate catch handler

If no matching catch block is found, the application terminates with an unhandled exception.

Why Do We Need the Throw Keyword in C#?

In real-world applications, not all errors occur automatically. Sometimes developers need to:

• Validate user input
• Enforce business rules
• Protect system resources
• Signal invalid operations

The throw statement in C# helps developers explicitly generate exceptions when certain conditions are met.

For example:

using System;

class Program
{
    static void Main()
    {
        int age = -5;

        if (age < 0)
        {
            throw new ArgumentException("Age cannot be negative.");
        }

        Console.WriteLine("Valid age.");
    }
}

In this example, the program throws an ArgumentException if the age is negative.

Syntax of Throw Statement in C#

Basic Syntax

throw new ExceptionType("Error message");

Syntax Explanation

• throw – Keyword used to raise an exception
• new – Creates an exception object
• ExceptionType – Built-in or custom exception class
• "Error message" – Descriptive message for debugging

How Throw Works in Exception Handling in C#

The throw keyword works closely with:

• try block
• catch block
• finally block

This structure is known as try catch finally in C#.

Example: Throw with Try-Catch

using System;

class Program
{
    static void Main()
    {
        try
        {
            int number = 0;

            if (number == 0)
            {
                throw new DivideByZeroException("Number cannot be zero.");
            }
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine("Exception caught: " + ex.Message);
        }
        finally
        {
            Console.WriteLine("Execution completed.");
        }
    }
}

Here:

• The exception is thrown inside the try block
• The catch block handles the exception
• The finally block executes regardless of error

Rethrowing Exceptions in C#

Sometimes you want to catch an exception, log it, and then rethrow it. This is called rethrowing an exception in C#.

Using throw Without Argument

using System;

class Program
{
    static void Main()
    {
        try
        {
            try
            {
                throw new Exception("Original Exception");
            }
            catch (Exception)
            {
                Console.WriteLine("Logging exception...");
                throw;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("Caught again: " + ex.Message);
        }
    }
}

Important:

• throw; preserves the original stack trace
• throw ex; resets the stack trace (not recommended)

Difference Between throw and throw ex in C#

Understanding this difference is critical for proper C# exception handling.

Using throw;

catch (Exception ex)
{
    throw;
}

• Preserves original stack trace
• Best practice

Using throw ex;

catch (Exception ex)
{
    throw ex;
}

• Resets stack trace
• Makes debugging harder

Always prefer throw; when rethrowing exceptions.

Built-in Exception Types in C#

Common built-in exceptions used with throw:

• ArgumentException
• ArgumentNullException
• InvalidOperationException
• NullReferenceException
• DivideByZeroException
• IndexOutOfRangeException

Example: ArgumentNullException

using System;

class Program
{
    static void PrintName(string name)
    {
        if (name == null)
        {
            throw new ArgumentNullException(nameof(name), "Name cannot be null.");
        }

        Console.WriteLine(name);
    }

    static void Main()
    {
        PrintName(null);
    }
}

Creating Custom Exceptions in C#

For business logic errors, developers often create custom exceptions in C#.

Step 1: Define Custom Exception Class

using System;

public class InvalidAgeException : Exception
{
    public InvalidAgeException(string message) : base(message)
    {
    }
}

Step 2: Use Throw with Custom Exception

using System;

class Program
{
    static void Main()
    {
        int age = 150;

        if (age > 120)
        {
            throw new InvalidAgeException("Age exceeds valid range.");
        }
    }
}

Custom exceptions improve readability and maintainability in enterprise applications.

Throw Expression in C#

From C# 7.0 onwards, the throw expression in C# allows throw to be used inside expressions.

Example: Throw in Ternary Operator

using System;

class Program
{
    static void Main()
    {
        string name = null;

        string result = name ?? throw new ArgumentNullException(nameof(name));

        Console.WriteLine(result);
    }
}

This feature makes code cleaner and more concise.

Real-World Scenario Example

using System;

class BankAccount
{
    public double Balance { get; private set; }

    public void Withdraw(double amount)
    {
        if (amount > Balance)
        {
            throw new InvalidOperationException("Insufficient funds.");
        }

        Balance -= amount;
    }
}

In banking systems, throwing exceptions prevents invalid financial transactions.

Advantages of Using Throw Keyword in C#

• Improves application reliability
• Separates error handling from business logic
• Enhances debugging capabilities
• Supports layered architecture
• Encourages defensive programming

Common Mistakes When Using Throw

• Using throw ex instead of throw
• Throwing general Exception
• Not documenting custom exceptions
• Ignoring exception handling
• Using exceptions for control flow

The C# throw keyword is a powerful mechanism in exception handling in C#. It enables developers to explicitly raise errors, enforce validation rules, and maintain application stability. Understanding how to use the throw statement in C#, how to rethrow exceptions correctly, and how to implement custom exceptions in C# is essential for professional software development.

When used properly with try catch finally in C#, the throw keyword ensures robust and maintainable code.