Throw and rethrow patterns in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of rethrowing an exception with throw;

What will be the output of this C# program when an exception is rethrown using throw; inside the catch block?

C Sharp (C#)

using System;
class Program {
    static void Main() {
        try {
            ThrowException();
        } catch (Exception ex) {
            Console.WriteLine("Caught: " + ex.Message);
            try {
                throw;
            } catch (Exception e) {
                Console.WriteLine("Rethrown caught: " + e.Message);
            }
        }
    }
    static void ThrowException() {
        throw new InvalidOperationException("Original error");
    }
}

A

Caught: Original error
Rethrown caught: Original error

B

Caught: Original error
Rethrown caught: Exception of type 'System.Exception' was thrown.

C

Caught: Original error
Rethrown caught: System.InvalidOperationException

D

Caught: Original error
Rethrown caught: System.InvalidOperationException: Original error

💡 Hint

Remember that using throw; preserves the original exception and its message.

Using throw; inside a catch block rethrows the original exception without changing its stack trace or message. So the message remains "Original error" in both catch blocks.

❓ Predict Output

intermediate

Effect of throw ex; vs throw; on stack trace

Consider this code snippet. What will be the output regarding the exception message and stack trace when using throw ex; instead of throw; inside the catch block?

C Sharp (C#)

using System;
class Program {
    static void Main() {
        try {
            ThrowException();
        } catch (Exception ex) {
            Console.WriteLine("Caught: " + ex.Message);
            try {
                throw ex; // Change this line to 'throw;' to compare
            } catch (Exception e) {
                Console.WriteLine("Rethrown caught: " + e.Message);
                Console.WriteLine(e.StackTrace.Split('\n')[0]);
            }
        }
    }
    static void ThrowException() {
        throw new InvalidOperationException("Original error");
    }
}

A

Caught: Original error
Rethrown caught: Original error
 at Program.Main() ...

B

Caught: Original error
Rethrown caught: Exception of type 'System.Exception' was thrown.

C

Caught: Original error
Rethrown caught: Original error
 at Program.ThrowException() ...

D

Caught: Original error
Rethrown caught: Original error
 at Program.Main() ... (stack trace reset)

💡 Hint

Using throw ex; resets the stack trace to the current throw point.

throw ex; creates a new throw point, resetting the stack trace to where it is thrown again, losing the original throw location. throw; preserves the original stack trace.

🔧 Debug

advanced

Identify the problem with rethrowing exception

This code tries to catch and rethrow an exception but causes unexpected behavior. What is the main problem?

C Sharp (C#)

try {
    DoWork();
} catch (Exception ex) {
    Log(ex.Message);
    throw ex;
}

void DoWork() {
    throw new Exception("Error in DoWork");
}

void Log(string message) {
    Console.WriteLine("Log: " + message);
}

A The Log method causes a runtime error.

B The catch block does not catch the exception properly.

C Using 'throw ex;' resets the stack trace, losing original error location.

D The exception message is lost after rethrowing.

💡 Hint

Consider how 'throw ex;' affects the stack trace compared to 'throw;'.

Using throw ex; resets the stack trace to the current throw point, which hides where the exception originally happened. This makes debugging harder.

🧠 Conceptual

advanced

Why prefer 'throw;' over 'throw ex;' when rethrowing?

Which of the following best explains why using throw; is preferred over throw ex; when rethrowing an exception in C#?

A There is no difference; both behave identically.

B <code>throw;</code> preserves the original stack trace, aiding debugging, while <code>throw ex;</code> resets it.

C <code>throw;</code> creates a new exception object, while <code>throw ex;</code> reuses the old one.

D <code>throw ex;</code> preserves the original stack trace, while <code>throw;</code> resets it.

💡 Hint

Think about what happens to the stack trace in each case.

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

❓ Predict Output

expert

Output when rethrowing inside nested try-catch

What is the output of this C# program that uses nested try-catch blocks and rethrows exceptions?

C Sharp (C#)

using System;
class Program {
    static void Main() {
        try {
            try {
                throw new Exception("Inner exception");
            } catch (Exception ex) {
                Console.WriteLine("Caught inner: " + ex.Message);
                throw;
            }
        } catch (Exception ex) {
            Console.WriteLine("Caught outer: " + ex.Message);
        }
    }
}

A

Caught inner: Inner exception
Caught outer: Inner exception

B Caught inner: Inner exception

C Caught outer: Inner exception

D No output, program crashes

💡 Hint

The inner catch rethrows the exception to the outer catch.

The inner catch prints the message, then rethrows the same exception. The outer catch then catches it again and prints the message.