When clause in catch in C Sharp (C#) - Time & Space Complexity

Time Complexity: When clause in catch

O(n)

Understanding Time Complexity

We want to understand how using a when clause in a catch block affects the time it takes for a program to handle errors.

Specifically, we ask: does adding a when condition change how long the program runs as input grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

try
{
    for (int i = 0; i < n; i++)
    {
        ProcessItem(i);
    }
}
catch (Exception ex) when (ex.Message.Contains("specific"))
{
    HandleSpecificError();
}
catch (Exception ex)
{
    HandleGeneralError();
}
    

This code processes n items in a loop and uses a when clause to catch exceptions with a specific message.

Identify Repeating Operations

• Primary operation: The for loop that runs ProcessItem(i) n times.
• How many times: Exactly n times, once for each item.
• Exception check: The when clause runs only if an exception occurs, checking the message condition.

How Execution Grows With Input

As n grows, the loop runs more times, so the main work grows with n.

Input Size (n)	Approx. Operations
10	About 10 calls to ProcessItem
100	About 100 calls to ProcessItem
1000	About 1000 calls to ProcessItem

Pattern observation: The main work grows directly with n. The when clause only runs if an exception happens, so it does not add repeated cost for normal runs.

Final Time Complexity

Time Complexity: O(n)

This means the program's running time grows in a straight line with the number of items processed, regardless of the when clause.

Common Mistake

[X] Wrong: "Adding a when clause makes the whole loop slower because it checks the condition every time."

[OK] Correct: The when clause only runs when an exception is thrown, which is usually rare. It does not slow down the normal loop iterations.

Interview Connect

Understanding how exception handling affects performance shows you can write clear and efficient error management. This skill helps you build reliable programs that handle problems without slowing down normal work.

Self-Check

What if the when clause checked a complex condition that runs every loop iteration instead of only on exceptions? How would the time complexity change?