Use when keyword in a try-catch pattern

In C#, the try-catch pattern is used to handle and manage exceptions that can occur during the execution of code. The try block contains the code that might throw an exception, and the catch block catches and handles the exception if it occurs. The when clause can be added to the catch block to specify additional conditions that must be true for the catch block to execute.

Here's an example of how you can implement the try-catch pattern with the when clause in C#:

try
{
    // Code that might throw an exception
}

catch (Exception ex) when (ex is InvalidOperationException || ex is ArgumentException)
{
    // Code to handle specific exceptions
}

catch (Exception ex)
{
    // Code to handle all other exceptions
}        

In the example above, the first catch block specifies that it will handle exceptions of type InvalidOperationException or ArgumentException only if the when clause is valid. The second catch block will handle all other exceptions.

You can also use the when clause to specify additional conditions based on the exception object. For example:

try
{
    // Code that might throw an exception
}

catch (ArgumentNullException ex) when (ex.ParamName == "input")
{
    // Code to handle ArgumentNullException with the "input" parameter name
}

catch (Exception ex)
{
    // Code to handle all other exceptions
}        

In this example, the first catch block will only execute if the caught exception is an ArgumentNullException with the ParamName property set to "input."

The when a keyword in a try-catch block in C# allows you to specify additional conditions that must be true for a particular catch block to execute. This can provide several benefits:

1. Fine-grained exception handling: You can use the when keyword to provide more specific handling of exceptions that meet certain criteria. This can make your code more precise and maintainable by allowing you to handle different exceptions differently.
2. Avoiding unnecessary catch blocks: By using the when keyword, you can filter out exceptions, you don't want to handle in a particular catch block. This can help you avoid unnecessary catch blocks that might catch exceptions you don't need to take.
3. Improved code readability: The when keyword can enhance the readability of your code by making it clear which catch block handles which type of exception and under what conditions.
4. Reduced code duplication: By using the when keyword, you can avoid duplicating exception handling code that applies to multiple catch blocks. Instead, you can apply the handling code to the specific catch block where it is needed.

Overall, using when a keyword in a try-catch block can help you write more precise and maintainable code while also improving the readability and reducing the duplication of your code.

let's have a real-world example

here's an example demonstrating the use of the when a keyword in a try-catch block in C#. In this example, we have a function that reads and processes data from a file. We want to handle exceptions that might occur during this process, but we also want to handle different types of exceptions in different ways.

static void ReadFileAndProcessData(string fileName)
{
    try
    {
        // Read data from the file and process it
        var data = File.ReadAllText(fileName);
        ProcessData(data);
    }

    catch (FileNotFoundException ex) when (ex.FileName == fileName)
    {
        // Handle the specific case of the file not being found
        Console.WriteLine($"The file {fileName} was not found.");
    }

    catch (IOException ex)
    {
        // Handle other input/output exceptions
        Console.WriteLine($"An I/O exception occurred: {ex.Message}");
    }

    catch (Exception ex)
    {
        // Handle all other exceptions
        Console.WriteLine($"An exception occurred: {ex.Message}");
    }
}        

In this example, we first try to read data from the specified file and process it using a function called ProcessData. If an exception occurs during this process, we catch it in a try-catch block. We have three catch blocks:

• The first catch block catches a FileNotFoundException that occurs when the specified file is not found. We use the when keyword to check if the FileName property of the exception matches the file name we passed in. If it does, we handle the specific case of the file not being found.
• The second catch block catches any other input/output exceptions that might occur, such as an UnauthorizedAccessException or a DirectoryNotFoundException. We handle these exceptions by displaying a generic error message that includes the exception message.
• The third catch block catches all other exceptions that might occur. We handle these exceptions by displaying a generic error message that includes the exception message.

By using the when a keyword in the first catch block, we can handle the specific case of the file not being found in a more precise and readable way while still running other exceptions in a more general way.

#cs_internship #csharp #step7