MSDN Documentation

Introduction to Exception Handling

Exception handling is a mechanism that responds to exceptional circumstances—or exceptions—that arise during program execution. In C#, exceptions are runtime errors that disrupt the normal flow of instructions. When an exception occurs, the program is terminated by default. Exception handling allows you to handle these situations gracefully, preventing your application from crashing and providing a better user experience.

The .NET Framework provides a rich hierarchy of exception classes derived from the System.Exception base class. Understanding this hierarchy and how to use exception handling effectively is crucial for writing robust and reliable C# applications.

The try-catch-finally Statement

The core of exception handling in C# is the try-catch-finally statement. It allows you to define a block of code where exceptions might occur, specify how to handle different types of exceptions, and define code that should always be executed.

try Block

The try block contains the code that might throw an exception.

catch Block

The catch block contains the code that executes if an exception of a specific type occurs within the try block. You can have multiple catch blocks to handle different exception types. A general catch block (e.g., catch (Exception)) can catch any type of exception.

finally Block

The finally block contains code that will always execute, regardless of whether an exception occurred or was caught. This is typically used for cleanup operations, such as releasing resources.

Example

try
{
    // Code that might throw an exception
    int result = Divide(10, 0); 
    Console.WriteLine($"Result: {result}");
}
catch (DivideByZeroException ex)
{
    // Handle division by zero exception
    Console.WriteLine($"Error: Cannot divide by zero. Details: {ex.Message}");
}
catch (ArgumentNullException ex)
{
    // Handle null argument exception
    Console.WriteLine($"Error: An argument was null. Details: {ex.Message}");
}
catch (Exception ex)
{
    // Handle any other unexpected exception
    Console.WriteLine($"An unexpected error occurred: {ex.Message}");
}
finally
{
    // This block always executes
    Console.WriteLine("Exception handling block finished.");
}

public static int Divide(int numerator, int denominator)
{
    if (denominator == 0)
    {
        throw new DivideByZeroException("The denominator cannot be zero.");
    }
    return numerator / denominator;
}
                

Common Exception Types

The .NET Framework provides a wide range of built-in exception types. Here are a few common ones:

• System.Exception: The base class for all exceptions.
• System.SystemException: Base class for exceptions thrown by the .NET Framework.
• System.ApplicationException: Base class for exceptions thrown by applications.
• System.ArgumentException: Thrown when one of the arguments provided to a method is not valid.
• System.ArgumentNullException: Derived from ArgumentException, thrown when a required argument is null.
• System.ArgumentOutOfRangeException: Derived from ArgumentException, thrown when an argument is outside the valid range of values.
• System.DivideByZeroException: Thrown when the denominator in a division operation is zero.
• System.IndexOutOfRangeException: Thrown when an attempt to access an element of an array with an invalid index is made.
• System.InvalidOperationException: Thrown when an operation is performed on an object that is in an invalid state for the requested operation.
• System.NullReferenceException: Thrown when an attempt to use an object reference that is currently null is made.
• System.NotImplementedException: Thrown when a requested method or operation is not implemented.
• System.IO.IOException: Base class for exceptions related to input/output operations.
• System.FormatException: Thrown when the format of a string or data is not valid for the operation.

You can throw these exceptions using the throw keyword:

if (user == null)
{
    throw new ArgumentNullException(nameof(user), "The user object cannot be null.");
}
                

Creating Custom Exceptions

Sometimes, the built-in exception types may not adequately describe the specific error conditions in your application. In such cases, you can create your own custom exception classes by inheriting from System.Exception or one of its derived classes.

A common practice is to create exceptions that derive from ApplicationException or more specific exceptions if appropriate.

// Define a custom exception
public class InsufficientFundsException : Exception
{
    public decimal CurrentBalance { get; }
    public decimal WithdrawalAmount { get; }

    public InsufficientFundsException() { }

    public InsufficientFundsException(string message) : base(message) { }

    public InsufficientFundsException(string message, Exception inner) : base(message, inner) { }

    public InsufficientFundsException(string message, decimal balance, decimal amount) 
        : base(message)
    {
        CurrentBalance = balance;
        WithdrawalAmount = amount;
    }
}

// Usage in a method
public void Withdraw(decimal amount)
{
    decimal currentBalance = GetBalance(); // Assume this method retrieves the balance
    if (amount > currentBalance)
    {
        throw new InsufficientFundsException($"Insufficient funds. Current balance: {currentBalance}, attempted withdrawal: {amount}", currentBalance, amount);
    }
    // Proceed with withdrawal logic
}
                

Best Practices for Exception Handling

Effective exception handling is key to building robust applications. Here are some best practices:

• Catch Specific Exceptions: Avoid catching the generic Exception class unless absolutely necessary. Catching more specific exceptions allows you to handle different error conditions appropriately.
• Don't Ignore Exceptions: Never use an empty catch block (catch {}). At a minimum, log the exception or re-throw it if you cannot handle it.
• Provide Informative Messages: Exception messages should be clear and helpful, providing enough information for debugging. Include relevant details like parameter values or object states.
• Use finally for Resource Cleanup: The finally block is the ideal place to release unmanaged resources (e.g., file handles, database connections) to prevent resource leaks.
• Keep try Blocks Small: The try block should contain only the code that could potentially throw an exception you intend to catch.
• Throw Exceptions Early: If a method's preconditions are not met, throw an exception immediately. Don't wait for a later stage where the error might be harder to diagnose.
• Use Custom Exceptions Appropriately: Create custom exceptions when built-in exceptions don't accurately represent the error condition.
• Consider Exception Handling Scope: Handle exceptions at the lowest practical level. If a specific component can handle an error, it should do so. Otherwise, let it propagate up the call stack.
• Document Exceptions: Clearly document the exceptions that your public methods can throw so that consumers of your API know how to handle them.