Try-Catch-Finally

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.

try
{
    // Guarded region: Code monitored by the CLR for exceptions
}
catch (InvalidOperationException ex) when (ex.InnerException != null)
{
    // Type-specific handler with an exception filter
}
catch (ArgumentException ex)
{
    // Type-specific handler
}
catch
{
    // Parameterless handler (catches all exceptions)
    throw; // Rethrows the exception preserving the original stack trace
}
finally
{
    // Termination handler: Executes during stack unwinding or normal completion
}

​

Component Mechanics

• Type Matching: The CLR binds the thrown exception to the first catch block that matches the exception’s type or a base type of the exception. Because of this top-down evaluation, catch blocks must be ordered from the most derived type to the least derived type (e.g., System.Exception must be last).
• Exception Filters (when keyword): Introduced in C# 6.0, filters allow a catch block to evaluate a boolean expression. If the expression evaluates to false, the CLR continues searching for a matching catch block without unwinding the call stack. This preserves the exact crash state for debugging.
• Parameterless Catch: A catch { } block without a type declaration catches all exceptions. In modern .NET (since .NET Framework 2.0 and across all versions of .NET Core/.NET 5+), the CLR automatically wraps non-CLS-compliant exceptions in System.Runtime.CompilerServices.RuntimeWrappedException, which inherits from System.Exception. Consequently, a parameterless catch block is functionally equivalent to catch (Exception).

• Jump Statement Restriction: Control is strictly prohibited from leaving the body of a finally block via jump statements (return, break, continue, goto). Attempting to do so results in compiler error CS0157.
• Exception Suppression: If a new exception is thrown within a finally block while the stack is unwinding for a previous exception, the original exception is suppressed and permanently lost. The new exception immediately propagates up the call stack.

​

Execution Flow and the Two-Pass Model

1. Pass One (Search): When an exception is thrown, the CLR suspends execution and searches up the call stack for a matching catch block. It evaluates types and when filters. No stack frames are popped, and no finally blocks are executed during this pass.
   • If no matching catch block is found anywhere in the call stack, the process terminates immediately. The stack is not unwound, and finally blocks are not executed.
2. Pass Two (Unwind): If a matching catch block is found during the first pass, the CLR unwinds the stack up to the frame containing the handler. As it pops each frame off the stack, it executes the finally blocks in those frames. Once the stack is unwound to the correct frame, the catch block executes, followed by the finally block of that specific frame.

• Normal Execution: The try block executes to completion. The CLR then executes the finally block. Control passes to the statement immediately following the finally block.
• Handled Exception: An exception is thrown. The CLR finds a match (Pass 1), unwinds the stack while executing intermediate finally blocks (Pass 2), executes the matching catch block, executes the local finally block, and passes control to the next statement.
• Unhandled Exception: An exception is thrown. The CLR searches the entire call stack but finds no match (Pass 1). The process terminates immediately. No finally blocks are executed.

​

Rethrowing Mechanics within catch

catch (Exception ex)
{
    // OPTION 1: BAD - Resets the stack trace to this line. Original throw point is lost.
    // throw ex; 
    
    // OPTION 2: GOOD - Preserves the original stack trace and exception state.
    // throw;    
    
    // OPTION 3: ALTERNATIVE - Wraps the exception, preserving the original as the InnerException.
    throw new CustomException("Message", ex); 
}