NeuroAgent

Best Practices for Catching Multiple Exceptions

Master exception handling in C# with efficient techniques for catching multiple exceptions simultaneously. Use exception filters with 'when' keyword to avoid repetitive code while maintaining type safety and performance.

#code-optimization #csharp-programming #error-handling #exception-filters #exception-handling #when-keyword

10/24/2025, 09:04 PM

Question

How to Catch Multiple Exceptions at Once in Programming?

When handling exceptions in programming, it’s generally discouraged to catch System.Exception errors. Instead, only the “known” exceptions should be caught. However, this approach can lead to repetitive code, as shown in the following example:

csharp

try
{
    WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
    WebId = Guid.Empty;
}
catch (OverflowException)
{
    WebId = Guid.Empty;
}

Is there a way to catch both exceptions and only set WebId = Guid.Empty once?

This example is relatively simple, but consider more complex scenarios where you modify an object multiple times. If one of the manipulations fails as expected, you might want to “reset” the object. However, if an unexpected exception occurs, you still want to throw it higher up the call stack.

What are the best practices for handling multiple specific exceptions without repetitive code in programming languages like C#?

NeuroAgent

In C#, you can catch multiple exceptions simultaneously using exception filters introduced in C# 6.0, which allow you to handle different exception types with a single catch block and avoid repetitive code. The modern approach uses the when keyword to specify conditions for different exception types within the same catch handler.

Exception Filters in C#
Alternative Approaches
Performance Considerations
Best Practices
Complex Object Reset Scenarios
Language-Specific Patterns

Exception Filters in C#

The most elegant solution for your problem is to use exception filters with the when keyword. This allows you to catch multiple exceptions in a single catch block while processing them differently:

csharp

try
{
    WebId = new Guid(queryString["web"]);
}
catch (Exception ex) when (ex is FormatException || ex is OverflowException)
{
    WebId = Guid.Empty;
}

This approach:

Maintains type safety by still catching specific exceptions
Avoids repetitive code in multiple catch blocks
Makes it clear that both exceptions are handled identically
Preserves the original exception for debugging purposes

You can also add more specific handling within the same block:

csharp

try
{
    // Multiple operations that might throw different exceptions
}
catch (Exception ex) when (ex is FormatException)
{
    WebId = Guid.Empty;
    LogWarning("Invalid format detected");
}
catch (Exception ex) when (ex is OverflowException)
{
    WebId = Guid.Empty;
    LogWarning("Overflow occurred");
}
catch (Exception ex) when (ex is NullReferenceException)
{
    // Handle differently
    throw new InvalidOperationException("Required parameter is missing", ex);
}

Alternative Approaches

Method-Based Exception Handling

For more complex scenarios, consider extracting the exception handling logic into a separate method:

csharp

private static Guid SafeParseGuid(string input)
{
    try
    {
        return new Guid(input);
    }
    catch (FormatException) when (string.IsNullOrEmpty(input))
    {
        return Guid.Empty;
    }
    catch (FormatException)
    {
        return Guid.Empty;
    }
    catch (OverflowException)
    {
        return Guid.Empty;
    }
}

// Usage
WebId = SafeParseGuid(queryString["web"]);

Custom Exception Types

Create a custom exception that wraps multiple scenarios:

csharp

public class GuidParseException : Exception
{
    public GuidParseException(Exception innerException) : base("Failed to parse GUID", innerException) { }
}

// In your code
try
{
    WebId = new Guid(queryString["web"]);
}
catch (FormatException ex) when (string.IsNullOrEmpty(queryString["web"]))
{
    throw new GuidParseException(ex);
}
catch (FormatException)
{
    WebId = Guid.Empty;
}
catch (OverflowException)
{
    WebId = Guid.Empty;
}

Performance Considerations

Exception filters are more performant than traditional multiple catch blocks because:

They don’t involve exception stack unwinding for the filtered exceptions
The exception object is created only once
No additional exception handling overhead

Important: The order of exception checking matters. More specific exceptions should be checked before general ones to avoid masking them.

csharp

// Correct order - more specific first
catch (Exception ex) when (ex is FormatException)
{
    // FormatException handling
}
catch (Exception ex) when (ex is OverflowException)
{
    // OverflowException handling
}
catch (Exception ex) when (ex is ArgumentException)
{
    // Generic argument handling
}

Best Practices

1. Be Specific About Exceptions

Always catch specific exceptions rather than general ones:

csharp

// Good - specific exceptions
catch (FormatException)
catch (OverflowException)

// Bad - too general
catch (Exception)

2. Preserve Exception Information

When handling exceptions, preserve important information:

csharp

catch (Exception ex) when (ex is FormatException || ex is OverflowException)
{
    // Log the original exception
    Logger.Error($"Failed to parse GUID: {ex.Message}");
    
    WebId = Guid.Empty;
}

3. Use Conditional Logic Within Filters

Complex conditional logic can be applied to exception filters:

csharp

catch (Exception ex) when (
    ex is FormatException && IsCriticalFormat(ex) ||
    ex is OverflowException && ShouldHandleOverflow(ex)
)
{
    WebId = Guid.Empty;
}

4. Consider Async/Await Patterns

For async operations, ensure proper exception handling:

csharp

try
{
    WebId = await Task.Run(() => new Guid(queryString["web"]));
}
catch (Exception ex) when (ex is FormatException || ex is OverflowException)
{
    WebId = Guid.Empty;
}

Complex Object Reset Scenarios

For complex object manipulation scenarios, implement a pattern that allows for atomic operations:

csharp

public class ComplexObject
{
    public void Reset()
    {
        // Reset all properties to safe defaults
        this.Property1 = default;
        this.Property2 = default;
        // ... other reset logic
    }

    public void SafeExecute(Action operation)
    {
        var backup = this.Clone(); // Create backup
        
        try
        {
            operation();
        }
        catch (Exception ex) when (IsExpectedException(ex))
        {
            this.Reset(); // Reset to safe state
            throw; // Re-throw expected exceptions
        }
        catch
        {
            this.Reset(); // Reset to safe state
            throw; // Re-throw unexpected exceptions
        }
    }

    private bool IsExpectedException(Exception ex)
    {
        return ex is FormatException || 
               ex is OverflowException || 
               ex is ArgumentException;
    }
}

// Usage
var obj = new ComplexObject();
obj.SafeExecute(() => 
{
    // Multiple operations that might throw expected exceptions
    obj.Property1 = ParseValue(input1);
    obj.Property2 = ParseValue(input2);
});

Language-Specific Patterns

Java and C# Similarities

Java also supports multiple exception catching:

java

try {
    WebId = UUID.fromString(queryString.get("web"));
} catch (IllegalArgumentException | NumberFormatException ex) {
    WebId = UUID.fromString("00000000-0000-0000-0000-000000000000");
}

Python Approach

Python uses multiple except clauses:

python

try:
    web_id = uuid.UUID(query_string['web'])
except (ValueError, OverflowError):
    web_id = uuid.UUID('{00000000-0000-0000-0000-000000000000}')

JavaScript/TypeScript

JavaScript uses try-catch with type checking:

typescript

try {
    const webId = new UUID(queryString.web);
} catch (ex) {
    if (ex instanceof FormatError || ex instanceof OverflowError) {
        webId = new UUID('00000000-0000-0000-0000-000000000000');
    }
    throw ex; // Re-throw unexpected exceptions
}

Conclusion

Catching multiple exceptions in C# can be elegantly handled using exception filters with the when keyword, which provides a clean solution to avoid repetitive catch blocks while maintaining type safety and performance. Key takeaways:

Use exception filters (when keyword) for handling multiple exceptions with similar logic
Preserve exception information even when handling multiple cases
Consider performance implications - exception filters are more efficient than multiple catch blocks
Implement atomic operations for complex object manipulation scenarios
Follow language-specific patterns while maintaining consistency

For your specific example with GUID parsing, the exception filter approach provides the most concise and maintainable solution while ensuring that both FormatException and OverflowException are handled appropriately.

Sources

What are the performance implications of using exception filters vs multiple catch blocks in C#?How to implement custom exception types for better error handling in C# applications?What are the best practices for exception handling in async/await patterns in C#?How to handle unexpected exceptions while preserving expected ones in C#?What are the differences in exception handling between C# and other programming languages?How to implement atomic operations with exception handling in complex object scenarios?

Ask NeuroAgent

Best Practices for Catching Multiple Exceptions

How to Catch Multiple Exceptions at Once in Programming?

Contents

Exception Filters in C#

Alternative Approaches

Method-Based Exception Handling

Custom Exception Types

Performance Considerations

Best Practices

1. Be Specific About Exceptions

2. Preserve Exception Information

3. Use Conditional Logic Within Filters

4. Consider Async/Await Patterns

Complex Object Reset Scenarios

Language-Specific Patterns

Java and C# Similarities

Python Approach

JavaScript/TypeScript

Conclusion

Sources