Throw and rethrow patterns in C Sharp (C#) - Mini Project: Build & Apply

Throw and Rethrow Patterns

📖 Scenario: Imagine you are building a simple calculator app that divides two numbers. Sometimes, the user might enter zero as the divisor, which causes an error. You want to catch this error, add a message, and then rethrow it so the program can handle it properly.

🎯 Goal: You will create a program that demonstrates how to throw and rethrow exceptions in C#. This helps you understand how to handle errors and pass them along with extra information.

📋 What You'll Learn

Create a method called Divide that takes two integers numerator and denominator.

Inside Divide, throw a DivideByZeroException if denominator is zero.

Use a try-catch block in Divide to catch the exception, add a message, and rethrow it.

In Main, call Divide and catch the rethrown exception to print its message.

💡 Why This Matters

🌍 Real World

Throwing and rethrowing exceptions is common in real apps to handle errors clearly and pass useful messages up the call chain.

💼 Career

Understanding exception handling is essential for writing robust, maintainable code in professional software development.

1

Create the Divide method with parameters

Create a method called Divide that takes two integer parameters named numerator and denominator. For now, just return 0 inside the method.

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
    }

    // Create the Divide method with two int parameters
    static int Divide(int numerator, int denominator)
    {
        // Your code here
        return 0;
    }
}

Hint

Define a method named Divide with two int parameters and return an int value.

2

Throw DivideByZeroException if denominator is zero

Inside the Divide method, add an if statement to check if denominator is zero. If it is, throw a new DivideByZeroException with the message "Cannot divide by zero."

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
    }

    static int Divide(int numerator, int denominator)
    {
        // Throw exception if denominator is zero
        if (denominator == 0)
        {
            // Your code here
        }
        return 0;
    }
}

Hint

Use throw new DivideByZeroException with the exact message inside the if block.

3

Catch and rethrow the exception with a message

Modify the Divide method to use a try-catch block. Put the if check and division inside the try. In the catch (DivideByZeroException ex), throw a new DivideByZeroException with the message "Error in Divide method: " plus the original exception message.

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
    }

    static int Divide(int numerator, int denominator)
    {
        try
        {
            // Your code here
        }
        catch (DivideByZeroException ex)
        {
            // Your code here
        }
    }
}

Hint

Use try-catch to catch the exception and rethrow with a new message combining your text and ex.Message.

4

Call Divide in Main and print the exception message

In the Main method, call Divide(10, 0) inside a try-catch block. Catch DivideByZeroException ex and print ex.Message using Console.WriteLine.

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
        // Your code here
    }

    static int Divide(int numerator, int denominator)
    {
        try
        {
            if (denominator == 0)
            {
                throw new DivideByZeroException("Cannot divide by zero.");
            }
            return numerator / denominator;
        }
        catch (DivideByZeroException ex)
        {
            throw new DivideByZeroException("Error in Divide method: " + ex.Message);
        }
    }
}

Hint

Use try-catch in Main to call Divide and print the exception message.

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