When clause in catch in C Sharp (C#) - Step-by-Step Execution

Concept Flow - When clause in catch

Try block starts

↓

Exception thrown?

No→Try block ends normally

Yes↓

Catch block with when clause

↓

Evaluate when condition

↓

Condition true?

No→Skip this catch

↓

Next catch or unhandled

↓

Execute catch block

↓

Continue after try-catch

When an exception occurs, the catch block with a when clause checks the condition; if true, it runs, else it skips to the next catch.

Execution Sample

C Sharp (C#)

try {
  int x = int.Parse("abc");
} catch (FormatException e) when (e.Message.Contains("Input")) {
  Console.WriteLine("Caught FormatException with 'Input' in message");
}

This code tries to parse a string to int and catches FormatException only if the message contains 'Input'.

Execution Table

Step	Action	Exception Thrown	When Condition Evaluated	Condition Result	Catch Block Executed	Output
1	Enter try block	No	N/A	N/A	No
2	int.Parse("abc") throws FormatException	FormatException	N/A	N/A	No
3	Catch block with when clause checks condition	FormatException	e.Message.Contains("Input")	True	Yes	Caught FormatException with 'Input' in message
4	Catch block executed, program continues	No	N/A	N/A	No

💡 Catch block executed because when condition was true; program continues normally.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
e.Message	N/A	"Input string was not in a correct format."	"Input string was not in a correct format."	"Input string was not in a correct format."

Key Moments - 2 Insights

Why does the catch block only run when the when condition is true?

Because the when clause acts like a filter; if the condition is false, the catch block is skipped (see execution_table row 3).

What happens if the when condition is false?

The catch block is skipped and the runtime looks for another catch block or the exception remains unhandled (not shown in this trace).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of the when condition at step 3?

A True

B False

C Not evaluated

D Exception message

💡 Hint

Check the 'Condition Result' column at step 3 in the execution_table.

At which step does the catch block actually execute?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look at the 'Catch Block Executed' column in the execution_table.

If the when condition was false, what would happen next?

A The catch block runs anyway

B The exception is ignored

C The runtime looks for another catch block

D The program crashes immediately

💡 Hint

Refer to the concept_flow where the false condition leads to skipping the catch block.

Concept Snapshot

try {
  // code that may throw
} catch (ExceptionType e) when (condition) {
  // runs only if condition is true
}

- The when clause filters exceptions
- If false, catch is skipped
- Helps handle exceptions selectively

Full Transcript

This example shows how the when clause in a catch block works in C#. When an exception is thrown inside the try block, the catch block with a when clause checks the condition. If the condition is true, the catch block runs and handles the exception. If false, it skips this catch and looks for another. This lets you handle exceptions more precisely based on extra conditions.

Practice

1.

What does the when clause do in a catch block in C#?

easy

A. It adds a condition to run the catch block only if the condition is true.

B. It defines a new exception type to catch.

C. It skips the catch block entirely.

D. It makes the catch block run before the try block.

Solution

1. Step 1: Understand the purpose of the when clause

   The when clause adds a condition to a catch block.

2. Step 2: Effect of the when clause in exception handling

   The catch block runs only if the condition after when is true, otherwise it skips.

3. Final Answer:

   It adds a condition to run the catch block only if the condition is true. -> Option A

4. Quick Check:

   when clause = conditional catch [OK]

Hint: when clause filters catch by condition [OK]

Common Mistakes:

• Thinking when defines a new exception type
• Assuming catch runs always regardless of when
• Confusing when with finally block

2.

Which of the following is the correct syntax to use a when clause in a catch block?

try {
    // code
} catch (Exception ex) _____ {
    // handle
}

easy

A. while (ex.Message.Contains("error"))

B. if (ex.Message.Contains("error"))

C. where (ex.Message.Contains("error"))

D. when (ex.Message.Contains("error"))

Solution

1. Step 1: Recall the correct keyword for condition in catch

   The correct keyword to add a condition in catch is when.

2. Step 2: Match the syntax with the options

   Only when (ex.Message.Contains("error")) uses when correctly with the condition.

3. Final Answer:

   when (ex.Message.Contains("error")) -> Option D

4. Quick Check:

   Use 'when' keyword for catch condition [OK]

Hint: Use 'when' keyword, not if/where/while in catch [OK]

Common Mistakes:

• Using if instead of when in catch
• Confusing when with where or while
• Missing parentheses after when

3.

What will be the output of this code?

try {
    throw new InvalidOperationException("Invalid operation");
} catch (InvalidOperationException ex) when (ex.Message.Contains("Invalid")) {
    Console.WriteLine("Caught invalid operation");
} catch (Exception) {
    Console.WriteLine("Caught general exception");
}

medium

A. Caught general exception

B. Caught invalid operation

C. No output

D. Runtime error

Solution

1. Step 1: Identify the thrown exception and matching catch

   The code throws InvalidOperationException with message containing "Invalid".

2. Step 2: Check the when condition in the first catch

   The first catch has a when clause checking if message contains "Invalid" which is true, so it runs.

3. Final Answer:

   Caught invalid operation -> Option B

4. Quick Check:

   when condition true runs first catch [OK]

Hint: Check exception type and when condition carefully [OK]

Common Mistakes:

• Ignoring the when condition and picking second catch
• Assuming no output if when is used
• Confusing exception types

4.

Find the error in this code snippet:

try {
    // some code
} catch (Exception ex) when ex.Message == "Error" {
    Console.WriteLine("Error caught");
}

medium

A. catch block must not have a condition

B. Cannot use when with Exception type

C. Missing parentheses around the when condition

D. Console.WriteLine is not allowed in catch

Solution

1. Step 1: Check syntax of when clause

   The condition after when must be enclosed in parentheses.

2. Step 2: Identify the missing parentheses in the code

   The code uses when ex.Message == "Error" without parentheses, which is invalid syntax.

3. Final Answer:

   Missing parentheses around the when condition -> Option C

4. Quick Check:

   when condition needs parentheses [OK]

Hint: Always put parentheses after when [OK]

Common Mistakes:

• Omitting parentheses around when condition
• Thinking when can't be used with Exception
• Believing catch can't have code inside

5.

Consider this code:

try {
    throw new ArgumentNullException("param");
} catch (ArgumentNullException ex) when (ex.ParamName == "param") {
    Console.WriteLine("Parameter error");
} catch (ArgumentNullException ex) {
    Console.WriteLine("Other argument null error");
}

What will be printed and why?

hard

A. Parameter error, because the when condition matches the ParamName.

B. Other argument null error, because when clause is ignored.

C. No output, because exception is not caught.

D. Runtime error due to duplicate catch blocks.

Solution

1. Step 1: Identify the thrown exception and its property

   The code throws ArgumentNullException with ParamName set to "param".

2. Step 2: Check the when clause condition in the first catch

   The first catch has a when clause checking if ex.ParamName == "param", which is true, so this catch runs.

3. Step 3: Understand catch block selection

   The second catch is ignored because the first matching catch with true when condition handles the exception.

4. Final Answer:

   Parameter error, because the when condition matches the ParamName. -> Option A

5. Quick Check:

   when true catches first matching block [OK]

Hint: when filters catch; first true condition wins [OK]

Common Mistakes:

• Ignoring when condition and picking second catch
• Thinking duplicate catch causes error
• Assuming exception is uncaught