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.<br>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.<br>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.<br>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.