Multiple Catch Blocks in C#

What are Multiple Catch Blocks in C#?

C# allows handling different types of exceptions separately using multiple catch blocks. This helps catch specific errors and execute different actions based on the exception type.

Key Features of Multiple Catch Blocks

• Handles different exception types separately.
• Prevents one exception type from incorrectly handling another.
• Allows executing specific recovery actions based on the exception.
• The most specific exception should be caught first before generic ones.

Example: Handling Multiple Exceptions

The following example demonstrates how multiple catch blocks handle different exceptions separately.

Example: Handling FormatException and DivideByZeroException

using System;

class Program
{
    static void Main()
    {
        try
        {
            Console.Write("Enter a number: ");
            int number = int.Parse(Console.ReadLine());

            int result = 100 / number; // May cause DivideByZeroException
            Console.WriteLine($"Result: {result}");
        }
        catch (FormatException ex)
        {
            Console.WriteLine($"Input Error: {ex.Message}");
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine($"Math Error: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"General Error: {ex.Message}");
        }
    }
}

// Possible Outputs:
// 1. Enter a number: abc
//    Input Error: Input string was not in a correct format.
// 2. Enter a number: 0
//    Math Error: Attempted to divide by zero.
        

Here, FormatException handles incorrect input, DivideByZeroException handles division by zero, and a general Exception block catches any other errors.

Catching Specific vs. General Exceptions

It is recommended to catch specific exceptions first before catching general exceptions to ensure proper handling.

try { /* Code */ }
catch (FormatException ex) { /* Handle input error */ }
catch (DivideByZeroException ex) { /* Handle math error */ }
catch (Exception ex) { /* Handle general errors */ }
                    

try { /* Code */ }
catch (Exception ex) { /* Handle all errors */ }
catch (FormatException ex) { /* Unreachable code */ }
                    

Using Multiple Catch Blocks with Finally

The finally block is useful for executing cleanup operations, regardless of whether an exception occurs.

Example: Using Finally with Multiple Catch Blocks

using System;
using System.IO;

class Program
{
    static void Main()
    {
        StreamReader reader = null;
        try
        {
            reader = new StreamReader("nonexistentfile.txt");
            Console.WriteLine(reader.ReadToEnd());
        }
        catch (FileNotFoundException ex)
        {
            Console.WriteLine($"File Not Found: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"General Error: {ex.Message}");
        }
        finally
        {
            if (reader != null)
            {
                reader.Close();
                Console.WriteLine("File closed.");
            }
        }
    }
}

// Output:
// File Not Found: Could not find file 'nonexistentfile.txt'.
// File closed.
        

The finally block ensures that resources are released even if an exception occurs.

Best Practices for Multiple Catch Blocks

• Catch specific exceptions first before a general Exception block.
• Avoid catching Exception unless necessary.
• Use a finally block to clean up resources.
• Log exceptions instead of suppressing them silently.
• Use exception filters in C# 6+ for better handling (e.g., catch (Exception ex) when (ex is FormatException)).