Exception Class Hierarchy in C#

Understanding Exception Class Hierarchy in C#

In C#, all exceptions are derived from the System.Exception class. The hierarchy helps categorize exceptions into different types, making it easier to handle specific errors.

Exception Class Hierarchy

The exception hierarchy in C# follows this structure:

System.Object
 └── System.Exception
      ├── System.SystemException
      │    ├── System.IndexOutOfRangeException
      │    ├── System.NullReferenceException
      │    ├── System.InvalidOperationException
      │    ├── System.StackOverflowException
      │    ├── System.OutOfMemoryException
      │    ├── System.DivideByZeroException
      │    ├── System.FormatException
      │    └── System.IO.IOException
      ├── System.ApplicationException (Base for custom exceptions)
      │    ├── CustomException1
      │    └── CustomException2
      └── Other Exception Classes

The System.Exception class serves as the base class for all exceptions, with System.SystemException handling runtime errors and System.ApplicationException allowing custom exceptions.

Common Built-in Exception Types

Here are some commonly used exceptions in C#:

Exception Type	Derived From	Description	Example
`IndexOutOfRangeException`	`SystemException`	Thrown when accessing an invalid array index.	`arr[10]` (when arr length is 5)
`NullReferenceException`	`SystemException`	Thrown when trying to access an object that is null.	`string s = null; s.Length;`
`DivideByZeroException`	`SystemException`	Thrown when dividing by zero.	`int x = 5 / 0;`
`InvalidOperationException`	`SystemException`	Thrown when an operation is not allowed.	`var item = list.First();` (when list is empty)
`IOException`	`SystemException`	Thrown when an I/O operation fails.	File not found, disk full, etc.

Creating Custom Exceptions

You can define your own exception by deriving from ApplicationException or Exception.

Example: Creating a Custom Exception

using System;

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

// Usage
class Program
{
    static void Main()
    {
        int age = 15;
        try
        {
            if (age < 18)
                throw new InvalidAgeException("Age must be 18 or older.");
        }
        catch (InvalidAgeException ex)
        {
            Console.WriteLine($"Custom Exception Caught: {ex.Message}");
        }
    }
}

// Output:
// Custom Exception Caught: Age must be 18 or older.

This custom exception checks if an age is below 18 and throws an error accordingly.

Handling Different Exception Types

You can handle multiple exception types using multiple catch blocks.

Example: Handling Multiple Exception Types

using System;

class Program
{
    static void Main()
    {
        try
        {
            int[] arr = new int[3];
            Console.WriteLine(arr[5]); // Will throw IndexOutOfRangeException
        }
        catch (IndexOutOfRangeException ex)
        {
            Console.WriteLine($"Index Error: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"General Error: {ex.Message}");
        }
    }
}

// Output:
// Index Error: Index was outside the bounds of the array.

The catch block for IndexOutOfRangeException executes first, as it is more specific.

When to Use Custom Exceptions?

When built-in exceptions do not describe your error properly.
To enforce business logic validation (e.g., "Age must be 18 or older").
To improve debugging and maintainability.
To categorize errors in large applications.