C# - Catch multiple exceptions

Catching multiple exceptions in C# is a technique used to handle different types of exceptions that may occur during the execution of a program. In C#, to handle errors, you can use a structure called a try-catch block. When you want to handle multiple exceptions, you can have multiple catch clauses, each designed to handle a specific type of exception. This way, you can respond differently to different errors, making your program more robust and user-friendly.

To handle various exceptions, utilize the catch block combined with the when keyword, which is followed by specific conditions that define the types of exceptions to be caught. Each of these conditions should be delineated using the or keyword.

Here's the syntax for catching multiple exceptions in C#:

try
{
    // Code that might raise an exception
}
catch (ExceptionType1 ex) when (condition1)
{
    // Exception handling code for ExceptionType1 when condition1 is true
}
catch (ExceptionType2 ex) when (condition2)
{
    // Exception handling code for ExceptionType2 when condition2 is true
}
// Add more catch blocks for other exception types as needed

using System;

class Program
{
    static void Main()
    {
        try
        {
            int result = Divide(10, 0);
            Console.WriteLine("Result: " + result); // This line won't be reached due to the exception
        }
        catch (DivideByZeroException ex) when (ex.Source == "CustomSource")
        {
            // Exception handling code for DivideByZeroException when the source is "CustomSource"
            Console.WriteLine("An error occurred while dividing by zero from CustomSource: " + ex.Message);
        }
        catch (DivideByZeroException ex)
        {
            // Exception handling code for DivideByZeroException
            Console.WriteLine("An error occurred while dividing by zero: " + ex.Message);
        }
        catch (ArithmeticException ex)
        {
            // Exception handling code for ArithmeticException
            Console.WriteLine("An arithmetic error occurred: " + ex.Message);
        }
        catch (Exception ex)
        {
            // Generic catch block for any other exceptions
            Console.WriteLine("An error occurred: " + ex.Message);
        }
        finally
        {
            // Cleanup code that always executes
            Console.WriteLine("The 'finally' block is executed regardless of exceptions.");
        }
    }

    static int Divide(int a, int b)
    {
        return a / b;
    }
}

Understanding the Output of the C# Program

This document explains the output of a given C# program which demonstrates exception handling.

Program Analysis

1. Initialization: The program begins in the Main method.
2. Try Block Execution:
   • The try block calls the Divide method with arguments 10 and 0.
   • A DivideByZeroException is thrown, skipping the next line in the try block.
3. Catching Exceptions:
   • The program checks for a matching catch block for the thrown exception.
   • The relevant catch block for DivideByZeroException is executed.
   • The error message "An error occurred while dividing by zero: [exception message]" is printed.
4. Finally Block Execution:
   • The finally block executes, printing "The 'finally' block is executed regardless of exceptions."

Expected Output

	An error occurred while dividing by zero: Attempted to divide by zero.
	The 'finally' block is executed regardless of exceptions.

This output showcases how C# manages exceptions and the role of the finally block in handling cleanup or final actions post exception handling.

Catching multiple exceptions can help you write more concise and organized exception handling code when dealing with related exception types that require similar handling logic.

Points to Remember:

Handling multiple exceptions in programming, especially in languages like C#, requires attention to several crucial points.

1. Use of Try-Catch Blocks: Use try-catch blocks to manage exceptions, with the try block containing potentially error-throwing code and the catch block handling these exceptions.
2. Multiple Catch Blocks: You can have various catch blocks after a single try block, each tailored for a different type of exception.
3. Exception Specificity: Begin with catch blocks for specific exceptions and progress to more general ones to ensure proper catching order.
4. Catch All Exception: Include a general catch block at the end to handle any unexpected exceptions.
5. Order of Catch Blocks: The sequence of catch blocks is crucial. General exception catch blocks should be placed last to avoid preempting specific ones.
6. Exception Handling Logic: In each catch block, implement appropriate logic for handling the exception, such as logging or user notifications.
7. Avoid Empty Catch Blocks: Refrain from using empty catch blocks as they can conceal errors, complicating debugging.
8. When Keyword Usage (C# specific): Use the when keyword in C# catch blocks for more refined exception filtering based on specific conditions.
9. Exception Propagation: Understand that uncaught exceptions will propagate up the call stack.
10. Finally Block: Use the finally block for code that should execute regardless of exception occurrence, typically for cleanup.

These guidelines offer a systematic approach to robust error handling in programming.