Exception Filters in C#

Understanding Exception Filters in C#

**Exception Filters** allow handling exceptions **conditionally** before executing a `catch` block. Introduced in **C# 6.0**, they improve **code readability** and **exception handling efficiency**.

Key Features of Exception Filters

Allows filtering **specific exception scenarios** before entering a `catch` block.
Improves **code readability** by avoiding nested `if` statements in `catch` blocks.
Prevents **unnecessary exception handling** when a condition isn't met.
Works well with **logging exceptions without catching them**.

Basic Usage of Exception Filters

Exception filters use the `when` keyword to specify **conditions** for handling exceptions.

Example: Using Exception Filters to Handle Specific Cases

using System;

class Program
{
    static void Main()
    {
        try
        {
            ThrowException(404);
        }
        catch (Exception ex) when (ex.Message.Contains("404"))
        {
            Console.WriteLine("Not Found Error Handled.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"General Exception: {ex.Message}");
        }
    }

    static void ThrowException(int errorCode)
    {
        if (errorCode == 404)
            throw new Exception("404 - Not Found");
        else
            throw new Exception("500 - Internal Server Error");
    }
}

// Output:
// Not Found Error Handled.

The `when (ex.Message.Contains("404"))` filter ensures that only `404` errors enter the first `catch` block.

Using Exception Filters for Logging Without Handling

Exception filters allow logging an exception **without catching it**, ensuring normal exception propagation.

Example: Logging Errors Using Exception Filters

using System;
using System.IO;

class Program
{
    static void Main()
    {
        try
        {
            ThrowError();
        }
        catch (Exception ex) when (LogError(ex))
        {
            // This block is not executed, but exception is logged.
        }
    }

    static void ThrowError()
    {
        throw new Exception("An unexpected error occurred.");
    }

    static bool LogError(Exception ex)
    {
        File.WriteAllText("error.log", $"Logged Error: {ex.Message}");
        Console.WriteLine("Error logged.");
        return false; // Allows exception to propagate
    }
}

// Output:
// Error logged.
// (Exception still propagates and crashes the program)

The **when (LogError(ex))** filter logs the exception **without handling it**, allowing normal exception propagation.

Combining Multiple Exception Filters

Exception filters can be **stacked** to handle different scenarios efficiently.

Example: Using Multiple Filters for Different Error Types

using System;

class Program
{
    static void Main()
    {
        try
        {
            ThrowCustomError(401);
        }
        catch (Exception ex) when (ex.Message.Contains("401"))
        {
            Console.WriteLine("Unauthorized Access Handled.");
        }
        catch (Exception ex) when (ex.Message.Contains("500"))
        {
            Console.WriteLine("Internal Server Error Handled.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Unhandled Exception: {ex.Message}");
        }
    }

    static void ThrowCustomError(int code)
    {
        if (code == 401) throw new Exception("401 - Unauthorized");
        if (code == 500) throw new Exception("500 - Server Error");
        throw new Exception("Unknown Error");
    }
}

// Output (for different codes):
// Unauthorized Access Handled. (if code is 401)
// Internal Server Error Handled. (if code is 500)
// Unhandled Exception: Unknown Error (for others)

Different `when` conditions handle **different error codes**, reducing the need for multiple `if` checks inside a single `catch` block.

Exception Filters vs Traditional `catch` Blocks

Feature	Traditional `catch`	Exception Filters (`when`)
Handles exceptions conditionally	❌ No	✅ Yes
Prevents unnecessary handling	❌ No	✅ Yes
Can log errors without catching	❌ No	✅ Yes
Requires additional `if` checks	✅ Yes	❌ No

Best Practices for Using Exception Filters

Use exception filters **to handle specific cases before catching exceptions**.
Use `when (LogError(ex))` to **log exceptions without handling them**.
Avoid **complex logic inside `when` filters**—keep conditions simple.
Use **multiple filters** instead of `if` checks inside `catch` blocks.