MSDN Documentation

C# Error Handling

Error handling is a crucial aspect of robust software development. In C#, exception handling provides a structured way to manage runtime errors, ensuring that unexpected situations are gracefully handled rather than causing program termination.

Understanding Exceptions

An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. When an error occurs, the .NET runtime throws an exception object. This object contains information about the error, including its type and the state of the program when the error occurred.

Common exception types include:

• ArgumentNullException: Thrown when a method receives a null argument that it does not accept.
• ArgumentOutOfRangeException: Thrown when an argument is outside the expected range of values.
• DivideByZeroException: Thrown when an attempt is made to divide an integer or decimal by zero.
• IndexOutOfRangeException: Thrown when an attempt is made to access an array element with an invalid index.
• NullReferenceException: Thrown when an attempt is made to use a reference that is currently null.
• InvalidOperationException: Thrown when a method call is invalid for the object's current state.

The try-catch-finally Statement

The primary mechanism for handling exceptions in C# is the try-catch-finally statement.

• try: The code that might potentially throw an exception is placed inside the try block.
• catch: If an exception occurs within the try block, the corresponding catch block is executed. You can have multiple catch blocks to handle different exception types.
• finally: The code in the finally block is always executed, regardless of whether an exception was thrown or caught. This is typically used for cleanup operations, such as closing files or releasing resources.

using System;

public class ExceptionExample
{
    public static void Main(string[] args)
    {
        try
        {
            int numerator = 10;
            int denominator = 0;
            int result = numerator / denominator; // This will throw DivideByZeroException
            Console.WriteLine($"The result is: {result}");
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine($"Error: Cannot divide by zero.");
            Console.WriteLine($"Details: {ex.Message}");
        }
        catch (Exception ex) // Catches any other type of exception
        {
            Console.WriteLine($"An unexpected error occurred.");
            Console.WriteLine($"Details: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("This block always executes.");
        }
    }
}
                

Exception Handling Strategies

When handling exceptions, consider the following strategies:

• Catch specific exceptions: Whenever possible, catch the most specific exception type first. This allows for targeted error handling.
• Use a general catch block wisely: A general catch (Exception ex) block should typically be the last one. It can be used to log unexpected errors or provide a generic error message.
• Re-throwing exceptions: Sometimes, you might catch an exception, perform some logging or cleanup, and then re-throw it to allow a higher level of the call stack to handle it. Use throw; for this purpose.
• Use using statements for disposable resources: The using statement simplifies the use of objects that implement the IDisposable interface, ensuring that their Dispose() method is called even if exceptions occur.

The throw Keyword

You can explicitly throw an exception using the throw keyword. This is useful for validating input or signaling error conditions that you detect.

using System;

public class InputValidator
{
    public static void ValidatePositiveNumber(int number)
    {
        if (number < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(number), "The number must be positive.");
        }
        Console.WriteLine($"Valid number: {number}");
    }

    public static void Main(string[] args)
    {
        try
        {
            ValidatePositiveNumber(-5);
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"Input validation failed: {ex.Message}");
        }
    }
}
                

Best Practices

• Handle exceptions at the appropriate level.
• Provide informative error messages.
• Log exceptions for debugging and monitoring.
• Don't use exceptions for normal control flow.
• Clean up resources in the finally block or using using statements.