Throw and rethrow patterns in C Sharp (C#)

Introduction

Throwing and rethrowing help you handle errors in your program. You can stop the program when something goes wrong or pass the error up to fix it later.

When you want to stop the program because something unexpected happened.

When you catch an error but want to add more information before passing it on.

When you want to log an error and then let another part of the program handle it.

When you want to clean up resources before passing the error up.

When you want to keep the original error details while handling it in multiple places.

Syntax

C Sharp (C#)

throw new Exception("Error message");

// To rethrow an existing exception inside a catch block:
throw;

// Or to throw a new exception with the caught one as inner:
throw new Exception("New message", ex);

throw creates a new error or passes an existing one.

Use throw; alone inside a catch to keep the original error details.

Examples

This stops the program and shows a new error message.

C Sharp (C#)

throw new Exception("Something went wrong");

This catches an error and immediately passes it up without changing it.

C Sharp (C#)

try {
    // code that may fail
} catch (Exception ex) {
    throw; // rethrows the same error
}

This catches an error, adds a new message, and keeps the original error inside.

C Sharp (C#)

try {
    // code that may fail
} catch (Exception ex) {
    throw new Exception("New error", ex); // wraps original error
}

Sample Program

This program shows how to throw a new error with an original error inside, and how to rethrow an error to keep its details.

C Sharp (C#)

using System;

class Program {
    static void Main() {
        try {
            CauseError();
        } catch (Exception ex) {
            Console.WriteLine("Caught in Main: " + ex.Message);
            throw; // rethrow to keep original error
        }
    }

    static void CauseError() {
        try {
            throw new Exception("Original error");
        } catch (Exception ex) {
            Console.WriteLine("Caught in CauseError: " + ex.Message);
            throw new Exception("Wrapped error", ex); // throw new with inner
        }
    }
}

Important Notes

Use throw; alone to keep the original stack trace.

Throwing a new exception with the old one inside helps add context.

Rethrowing without losing details helps debugging later.

Summary

Throw stops the program with an error.

Rethrow passes the caught error up without changing it.

You can wrap errors to add more information.

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