C# - Try and Catch

Exception Handling with Filters in C#

Exception filters allow you to conditionally handle exceptions. They are specified using the when keyword.

The when keyword in C# allows you to specify a filter condition for a catch block. This condition is evaluated when an exception is thrown, and the catch block will only handle the exception if the condition evaluates to true. This feature is known as exception filters.

Exception filters are useful for:

• Selective Handling: Handling exceptions only when certain conditions are met.
• Simplifying Code: Reducing the need for nested try-catch blocks or complex if statements within catch blocks.
• Maintaining Readability: Keeping exception handling logic cleaner and more readable.

Syntax and Example

try
{
    // Code that may throw an exception
}
catch (Exception ex) when (Condition)
{
    // Handle the exception if the condition is true
}

Detailed Example

Let's say you are working with a method that might throw different types of exceptions, and you want to handle some of them based on specific conditions.

public void ProcessData()
{
    try
    {
        // Code that may throw an exception
        ThrowExceptionBasedOnCondition();
    }
    catch (Exception ex) when (ex is InvalidOperationException && ex.Message.Contains("specific error"))
    {
        // Handle InvalidOperationException only if the message contains "specific error"
        Console.WriteLine("Caught specific InvalidOperationException: " + ex.Message);
    }
    catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
    {
        // Handle both IOException and UnauthorizedAccessException
        Console.WriteLine("Caught IO or UnauthorizedAccessException: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle any other exceptions
        Console.WriteLine("Caught general exception: " + ex.Message);
    }
}

public void ThrowExceptionBasedOnCondition()
{
    // Simulate different exceptions
    throw new InvalidOperationException("This is a specific error.");
}

In this example:

1. The first catch block handles InvalidOperationException only if the exception message contains the string "specific error".

The second catch block handles both IOException and UnauthorizedAccessException.

The final catch block is a general catch-all for any other exceptions that might be thrown.

Benefits of Using Exception Filters

1. Conditional Handling: You can handle exceptions based on additional runtime information, not just the type of the exception.

catch (Exception ex) when (ex is ArgumentException && ((ArgumentException)ex).ParamName == "name")
{
    // Handle ArgumentException only if the parameter name is "name"
}

2.Avoiding Nested Try-Catch: Simplify your error-handling code by avoiding nested try-catch blocks.

try
{
    // Code that may throw an exception
}
catch (Exception ex) when (ShouldHandleException(ex))
{
    // Handle exception based on custom logic
}

3. Improving Readability: Exception filters make the code more readable by keeping the condition for handling the exception alongside the catch block.

try
{
    // Code that may throw an exception
}
catch (Exception ex) when (LogAndHandle(ex))
{
    // Handle and log the exception
}

private bool LogAndHandle(Exception ex)
{
    // Log the exception
    Console.WriteLine("Logging exception: " + ex.Message);
    // Determine if the exception should be handled
    return ex.Message.Contains("Handle this exception");
}

Conclusion 
Exception filters with the when keyword provide a powerful and expressive way to handle exceptions conditionally in C#. They help maintain cleaner and more readable code by allowing you to specify the conditions under which certain exceptions should be caught. By using exception filters, you can write more precise and efficient error-handling code.