Try-catch execution flow in C Sharp (C#) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of a try-catch block in C#?

A try-catch block is used to handle errors (exceptions) that might happen during program execution, so the program can continue running safely instead of crashing.

beginner

What happens if an exception occurs inside the try block?

The program immediately stops running the try block and jumps to the catch block that matches the exception type to handle the error.

beginner

Can code after the try-catch block run if an exception is caught?

Yes, after the catch block finishes, the program continues running the code that comes after the try-catch block.

intermediate

What is the role of the finally block in try-catch-finally?

The finally block runs code that must execute no matter what, whether an exception happened or not, like closing files or releasing resources.

beginner

If no exception occurs in the try block, does the catch block run?

No, if the try block runs without errors, the catch block is skipped and the program continues normally.

What happens when an exception is thrown inside a try block?

A Execution jumps to the matching catch block.

B The program immediately stops running.

C The code after the try block runs first.

D The exception is ignored.

When an exception occurs, the program jumps to the catch block that matches the exception type to handle it.

Which block always runs regardless of exceptions?

A finally

B catch

C try

D none

The finally block always runs after try and catch, whether or not an exception occurred.

If no exception occurs, which blocks run?

A try and catch

B try and finally

C catch and finally

D try only

If no exception happens, the try block runs, then the finally block runs if present.

Can multiple catch blocks be used for one try block?

A Only if they are nested.

B No, only one catch block is allowed.

C Only if the exceptions are the same type.

D Yes, to handle different exception types.

Multiple catch blocks can be used to handle different types of exceptions separately.

What happens to code after the try-catch-finally block?

A It runs only if no exception occurred.

B It runs only if an exception was caught.

C It always runs after the try-catch-finally block finishes.

D It never runs if an exception occurs.

After the try-catch-finally block finishes, the program continues running the code that follows.

Explain the flow of execution in a try-catch-finally block when an exception occurs.

Think about what happens step-by-step when an error happens inside try.

Describe what happens if no exception occurs inside the try block.

Consider the normal flow without errors.

Practice

1. What happens when an exception occurs inside a try block in C#?

easy

A. The program immediately jumps to the catch block to handle the error.

B. The program ignores the error and continues running the try block.

C. The program stops running without executing any further code.

D. The program restarts the try block from the beginning.

Solution

1. Step 1: Understand try-catch flow

   The try block runs code that might cause an error.

2. Step 2: Exception triggers catch block

   If an error happens, control moves to the catch block to handle it.

3. Final Answer:

   The program immediately jumps to the catch block to handle the error. -> Option A

4. Quick Check:

   Exception in try -> catch runs [OK]

Hint: Errors in try always jump to catch block [OK]

Common Mistakes:

• Thinking the program ignores errors in try
• Assuming the program restarts try block
• Believing the program stops without catch

2. Which of the following is the correct syntax to catch an exception in C#?

easy

A. try { /* code */ } catch (ex Exception) { /* handle */ }

B. try { /* code */ } catch Exception ex { /* handle */ }

C. try { /* code */ } catch { Exception ex } { /* handle */ }

D. try { /* code */ } catch (Exception ex) { /* handle */ }

Solution

1. Step 1: Recall correct catch syntax

   The catch block must have parentheses with exception type and variable: catch (Exception ex).

2. Step 2: Identify correct option

   Only try { /* code */ } catch (Exception ex) { /* handle */ } uses the correct syntax with parentheses and exception variable.

3. Final Answer:

   try { /* code */ } catch (Exception ex) { /* handle */ } -> Option D

4. Quick Check:

   Correct catch syntax = catch (Exception ex) [OK]

Hint: Catch needs parentheses with exception type and variable [OK]

Common Mistakes:

• Omitting parentheses around exception
• Swapping exception type and variable order
• Using braces instead of parentheses

3. What will be the output of this C# code?

try {
    Console.WriteLine("Start");
    int x = 5 / 0;
    Console.WriteLine("End");
} catch (DivideByZeroException) {
    Console.WriteLine("Error caught");
}

medium

A. Start\nError caught

B. Error caught

C. Start\nEnd

D. Start

Solution

1. Step 1: Trace code inside try block

   "Start" prints first. Then division by zero causes an exception.

2. Step 2: Exception triggers catch block

   Catch block runs and prints "Error caught". The line after division is skipped.

3. Final Answer:

   Start\nError caught -> Option A

4. Quick Check:

   Exception skips rest of try, catch prints message [OK]

Hint: Exception skips rest of try, catch runs next [OK]

Common Mistakes:

• Assuming 'End' prints after exception
• Thinking catch runs before 'Start'
• Ignoring exception and continuing try

4. Identify the error in this C# code snippet:

try {
    int[] arr = new int[2];
    arr[3] = 10;
} catch (Exception e) {
    Console.WriteLine("Exception caught");
}

medium

A. Array index out of bounds exception is not caught.

B. The catch block syntax is incorrect.

C. The code will throw an exception but catch block handles it correctly.

D. The try block has a syntax error.

Solution

1. Step 1: Analyze the try block code

   Accessing index 3 in an array of size 2 causes an IndexOutOfRangeException.

2. Step 2: Check catch block handling

   Catch block catches all exceptions of type Exception, so it will handle this error and print the message.

3. Final Answer:

   The code will throw an exception but catch block handles it correctly. -> Option C

4. Quick Check:

   Exception thrown and caught properly [OK]

Hint: Catch(Exception e) catches all exceptions [OK]

Common Mistakes:

• Thinking catch syntax is wrong
• Assuming exception is not caught
• Believing try block has syntax error

5. Consider this code:

try {
    Console.WriteLine("A");
    try {
        int y = int.Parse("abc");
    } catch (FormatException) {
        Console.WriteLine("Format error");
    }
    Console.WriteLine("B");
} catch (Exception) {
    Console.WriteLine("General error");
}

What will be the output?

hard

A. A\nGeneral error\nB

B. A\nFormat error\nB

C. Format error\nB

D. A\nB

Solution

1. Step 1: Trace outer try block

   Prints "A" first, then enters inner try block.

2. Step 2: Inner try-catch handles FormatException

   Parsing "abc" causes FormatException, caught by inner catch which prints "Format error".

3. Step 3: Continue outer try after inner catch

   After inner catch, prints "B". Outer catch is not triggered.

4. Final Answer:

   A\nFormat error\nB -> Option B

5. Quick Check:

   Inner catch handles error, outer continues [OK]

Hint: Inner catch handles error, outer try continues after [OK]

Common Mistakes:

• Assuming outer catch runs instead of inner
• Thinking code stops after inner exception
• Missing that 'B' prints after inner catch