Throw and rethrow patterns in C Sharp (C#) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the difference between throw; and throw ex; in C#?

throw; rethrows the current exception preserving the original stack trace.
throw ex; throws the exception as new, resetting the stack trace to the current location.

beginner

Why should you prefer throw; over throw ex; when rethrowing exceptions?

Using throw; keeps the original error location visible in the stack trace, which helps debugging.
Using throw ex; hides the original error location.

beginner

What happens if you catch an exception and do not rethrow it?

The exception is considered handled and will not propagate further.
This can be useful if you want to recover or log the error without stopping the program.

beginner

Show a simple example of rethrowing an exception preserving the stack trace.

try {
    // code that may throw
} catch (Exception ex) {
    // log or handle
    throw; // rethrow preserving stack trace
}

beginner

What is a common mistake when rethrowing exceptions in C#?

Using throw ex; instead of throw;, which resets the stack trace and makes debugging harder.

Which statement correctly rethrows an exception preserving the original stack trace?

A throw ex.InnerException;

B throw ex;

C throw new Exception();

D throw;

throw; rethrows the current exception preserving the original stack trace.

What happens if you use throw ex; inside a catch block?

A The exception is rethrown with the original stack trace.

B The program terminates immediately.

C The exception is rethrown but the stack trace is reset to this point.

D The exception is swallowed and not thrown again.

throw ex; resets the stack trace to the current throw location, losing the original error location.

Why might you catch an exception and not rethrow it?

A To ignore the error silently.

B To log or recover from the error without stopping the program.

C To crash the program faster.

D To create a new exception.

Sometimes you want to handle the error gracefully, log it, or recover without stopping the program.

Which of these is a best practice when rethrowing exceptions?

A Use <code>throw;</code> to preserve stack trace.

B Wrap exceptions in new exceptions without preserving original.

C Always use <code>throw ex;</code>.

D Never catch exceptions.

Using throw; preserves the original stack trace, which helps debugging.

What does the stack trace show when you use throw; inside a catch block?

A The original location where the exception was thrown.

B The location of the <code>throw;</code> statement.

C No stack trace is shown.

D The location of the catch block only.

throw; preserves the original stack trace, showing where the exception first occurred.

Explain the difference between throwing and rethrowing exceptions in C# and why preserving the stack trace matters.

Think about how the error location is shown in debugging tools.

Describe a scenario where you would catch an exception and choose not to rethrow it.

Consider when you want your program to keep running after an error.

Practice

1. What does the throw statement do in C# exception handling?

easy

A. It logs the error without stopping the program.

B. It ignores the error and continues execution.

C. It stops the program and signals an error.

D. It automatically fixes the error and resumes.

Solution

1. Step 1: Understand the purpose of throw

   The throw statement is used to signal that an error has occurred and to stop normal program flow.

2. Step 2: Recognize program behavior on throw

   When throw is executed, the program stops and looks for a matching catch block or terminates if none is found.

3. Final Answer:

   It stops the program and signals an error. -> Option C

4. Quick Check:

   throw stops program = C [OK]

Hint: Throw always stops execution and signals an error [OK]

Common Mistakes:

• Thinking throw continues program normally
• Confusing throw with logging
• Assuming throw fixes errors automatically

2. Which of the following is the correct syntax to rethrow an exception in a catch block without changing it?

easy

A. throw catch;

B. throw ex;

C. throw new Exception();

D. throw;

Solution

1. Step 1: Identify rethrow syntax

   To rethrow the caught exception preserving the original stack trace, use throw; without specifying the exception variable.

2. Step 2: Understand difference from throw ex;

   throw ex; resets the stack trace, which is not a pure rethrow.

3. Final Answer:

   throw; -> Option D

4. Quick Check:

   Rethrow syntax = throw; [OK]

Hint: Use plain 'throw;' to rethrow without losing stack trace [OK]

Common Mistakes:

• Using 'throw ex;' which resets stack trace
• Trying to throw a new exception instead
• Using invalid syntax like 'throw catch;'

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

try {
  throw new Exception("Error 1");
} catch (Exception ex) {
  Console.WriteLine(ex.Message);
  throw;
}

medium

A. Error 1 printed, then program terminates with the same exception.

B. No output, program silently terminates.

C. Error 1 printed, then program continues normally.

D. Compilation error due to missing catch block.

Solution

1. Step 1: Analyze the try block

   The try block throws an exception with message "Error 1".

2. Step 2: Analyze the catch block

   The catch block prints the exception message, then rethrows the same exception using throw;.

3. Step 3: Understand program flow after rethrow

   Since the exception is rethrown and not caught again, the program terminates with the same exception after printing.

4. Final Answer:

   Error 1 printed, then program terminates with the same exception. -> Option A

5. Quick Check:

   Print then rethrow = B [OK]

Hint: Rethrow after print causes termination with printed message [OK]

Common Mistakes:

• Assuming program continues after rethrow
• Thinking no output is printed
• Confusing rethrow with new exception creation

4. Identify the error in this code snippet:

try {
  // some code
} catch (Exception ex) {
  throw ex;
}

medium

A. Try block must have a finally block.

B. Using throw ex; resets the stack trace, losing original error info.

C. Cannot catch Exception type directly.

D. Missing semicolon after throw ex.

Solution

1. Step 1: Understand throw ex; effect

   Using throw ex; throws the exception but resets the stack trace, losing original error location.

2. Step 2: Identify correct rethrow method

   To preserve stack trace, use throw; without specifying the exception variable.

3. Final Answer:

   Using throw ex; resets the stack trace, losing original error info. -> Option B

4. Quick Check:

   Throwing exception variable resets stack trace = D [OK]

Hint: Use 'throw;' not 'throw ex;' to keep original stack trace [OK]

Common Mistakes:

• Thinking 'throw ex;' preserves stack trace
• Believing finally block is mandatory
• Assuming Exception cannot be caught directly

5. You want to catch an exception, add extra info, and then rethrow it preserving the original stack trace. Which pattern is correct?

try {
  // code
} catch (Exception ex) {
  // add info
  ???
}

hard

A. throw new Exception("Extra info", ex);

B. throw ex;

C. throw;

D. throw new Exception(ex.Message);

Solution

1. Step 1: Understand wrapping exceptions

   To add extra info, create a new exception with the original as inner exception: new Exception("Extra info", ex).

2. Step 2: Preserve original stack trace

   This wrapping keeps original exception details inside the new one, preserving context.

3. Step 3: Why not other options?

   throw ex; resets stack trace, throw; rethrows original without extra info, and throw new Exception(ex.Message); loses original exception object.

4. Final Answer:

   throw new Exception("Extra info", ex); -> Option A

5. Quick Check:

   Wrap with new Exception and inner ex = A [OK]

Hint: Wrap original in new Exception to add info and preserve trace [OK]

Common Mistakes:

• Using 'throw ex;' which loses stack trace
• Using 'throw;' which loses added info
• Creating new Exception without inner exception