Try-Catch

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

​

Syntax

using System;
using System.IO;

public class ExceptionHandlingExample
{
    public void Execute()
    {
        try
        {
            // Guarded region: Code that may throw an exception
            string content = File.ReadAllText("data.txt");
        }
        catch (FileNotFoundException ex) when (ex.FileName != null)
        {
            // Handler for FileNotFoundException that meets the filter condition
            Console.WriteLine($"File not found: {ex.FileName}");
        }
        catch (IOException ex)
        {
            // Handler for IOException
            Console.WriteLine($"I/O error: {ex.Message}");
        }
        catch (Exception ex)
        {
            // Fallback handler for any exception derived from System.Exception
            Console.WriteLine($"General error: {ex.Message}");
        }
        finally
        {
            // Execution region: Runs regardless of exception occurrence
            Console.WriteLine("Execution completed.");
        }
    }
}

​

Core Components

​

1. The try Block

​

2. The catch Block

• Type Matching: The CLR evaluates catch blocks sequentially. It executes the first block where the thrown exception’s type matches, or is derived from, the declared exception type.
• Ordering: Because of sequential evaluation, catch blocks must be ordered from the most specific (most derived) exception type to the least specific (base) type. A compilation error occurs if a base class catch block precedes a derived class catch block. Furthermore, a general catch { } block cannot be combined with a catch (Exception) block on the same try statement, as catch (Exception) already catches all exceptions, rendering the general block unreachable (Compiler Error CS0160).
• The Exception Variable: Declaring a variable (e.g., ex) captures the exception object, granting access to its properties, such as Message, StackTrace, and InnerException. The variable can be omitted if the exception object itself is not needed (catch (IOException)).

​

3. Exception Filters (when Keyword)

• Stack Preservation: Exception filters are evaluated during the first pass of the CLR’s exception handling model. Because the stack is not unwound during this pass, if the filter evaluates to false, the CLR continues searching for a handler while preserving the original stack context and memory state for debugging.

​

4. The finally Block

• Execution Exceptions: The finally block is not absolutely guaranteed to execute. In modern .NET (.NET Core and .NET 5+), if an exception is completely unhandled across the entire call stack, finally blocks do not execute. The runtime terminates the process immediately to preserve the memory state for crash dumps. Additionally, finally blocks are bypassed if the process is terminated abruptly via Environment.FailFast() or Environment.Exit(), or due to catastrophic runtime failures such as a StackOverflowException.

​

Exception Propagation and Re-throwing

using System;

public class RethrowExample
{
    public void ProcessDataCorrectly()
    {
        try
        {
            PerformOperation();
        }
        catch (InvalidOperationException)
        {
            // Alternative 1: Preserving the stack trace (Correct)
            // Logs or processes the exception, then re-throws
            throw; 
        }
    }

    public void ProcessDataIncorrectly()
    {
        try
        {
            PerformOperation();
        }
        catch (InvalidOperationException ex)
        {
            // Alternative 2: Overwriting the stack trace (Generally Incorrect)
            // Treats the exception as a newly thrown object
            throw ex; 
        }
    }

    private void PerformOperation()
    {
        throw new InvalidOperationException("Operation failed.");
    }
}