C# Interview Questions

Use of try, catch, finally, and throw in Exception Handling

Exception handling in C# is a structured way of detecting and responding to runtime errors in a program. The key constructs used for exception handling are try, catch, finally, and throw. These constructs allow developers to manage exceptions, clean up resources, and propagate errors.

try Block

The try block contains the code that might throw an exception. When an exception occurs within this block, control is transferred to the appropriate catch block.

Example:

try
{
    // Code that might throw an exception
    int result = 10 / 0;
}

catch Block

The catch block contains the code that handles the exception. You can have multiple catch blocks to handle different types of exceptions specifically.

Example:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    // Handle specific exception
    Console.WriteLine("Cannot divide by zero.");
}
catch (Exception ex)
{
    // Handle any other exceptions
    Console.WriteLine($"An error occurred: {ex.Message}");
}

finally Block

The finally block contains code that is always executed, regardless of whether an exception was thrown or caught. It is typically used for cleaning up resources such as closing files, releasing network connections, etc.

Example:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Cannot divide by zero.");
}
catch (Exception ex)
{
    Console.WriteLine($"An error occurred: {ex.Message}");
}
finally
{
    // Code that will always execute
    Console.WriteLine("Finally block executed.");
}

throw Statement

The throw statement is used to explicitly throw an exception. This can be done either to raise a new exception or to rethrow an exception that has been caught.

Throwing a New Exception

Example:

public void Divide(int numerator, int denominator)
{
    if (denominator == 0)
    {
        throw new DivideByZeroException("Denominator cannot be zero.");
    }
    int result = numerator / denominator;
}

Rethrowing an Exception

Example:

try
{
    // Some code that might throw an exception
}
catch (Exception ex)
{
    // Log the exception or perform some action
    Console.WriteLine($"An error occurred: {ex.Message}");
    
    // Rethrow the exception
    throw;
}

Combining try, catch, finally, and throw

Here's an example that combines all these constructs:

Example:

public class Program
{
    public static void Main()
    {
        try
        {
            ProcessData();
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
        catch (Exception ex)
        {
            Console.WriteLine("An unexpected error occurred: " + ex.Message);
        }
        finally
        {
            Console.WriteLine("Execution completed.");
        }
    }

    public static void ProcessData()
    {
        try
        {
            int result = Divide(10, 0);
            Console.WriteLine($"Result: {result}");
        }
        catch (Exception ex)
        {
            // Log exception or perform some action
            Console.WriteLine("Processing error: " + ex.Message);
            // Rethrow the exception to be handled by the outer catch block
            throw;
        }
        finally
        {
            // Perform cleanup actions
            Console.WriteLine("ProcessData finally block executed.");
        }
    }

    public static int Divide(int numerator, int denominator)
    {
        if (denominator == 0)
        {
            throw new DivideByZeroException("Denominator cannot be zero.");
        }
        return numerator / denominator;
    }
}

Explanation:

• The Main method calls ProcessData within a try block.
• If ProcessData throws a DivideByZeroException, it is caught and handled specifically.
• If any other exception occurs, it is caught by the generic catch block.
• The finally block in both Main and ProcessData ensures that cleanup code is executed regardless of whether an exception was thrown or not.
• The ProcessData method demonstrates rethrowing an exception using the throw statement.

Summary

• try: Contains code that might throw an exception.
• catch: Handles exceptions thrown in the try block. Multiple catch blocks can be used to handle different types of exceptions.
• finally: Contains code that executes regardless of whether an exception was thrown or caught. Used for cleanup.
• throw: Explicitly throws an exception, either new or rethrowing a caught exception.

Using these constructs effectively ensures that your C# programs can handle errors gracefully, maintain resource integrity, and provide a better user experience.