Exception hierarchy in .NET in C Sharp (C#) - Mini Project: Build & Apply

Exception hierarchy in .NET

📖 Scenario: Imagine you are building a simple program that processes user input and might encounter different types of errors. You want to understand how exceptions are organized in .NET so you can handle them properly.

🎯 Goal: You will create a small program that defines a few exceptions following the .NET exception hierarchy and demonstrates catching them in order.

📋 What You'll Learn

Create a base exception class called MyAppException that inherits from System.Exception.

Create two derived exception classes: InputException and ProcessingException that inherit from MyAppException.

Write a method ProcessInput that throws InputException if input is empty and ProcessingException if input is "error".

Use a try-catch block to catch exceptions in order: first InputException, then ProcessingException, then MyAppException, and finally Exception.

💡 Why This Matters

🌍 Real World

Understanding exception hierarchy helps you write robust programs that can handle errors clearly and maintainably.

💼 Career

Many software development jobs require good error handling skills to build reliable applications.

1

Create base exception class

Create a class called MyAppException that inherits from System.Exception and has a constructor that takes a string message and passes it to the base constructor.

C Sharp (C#)

# Your code here

Hint

Remember to inherit from Exception and call the base constructor with the message.

2

Create derived exception classes

Create two classes called InputException and ProcessingException that both inherit from MyAppException. Each should have a constructor that takes a string message and passes it to the base constructor.

C Sharp (C#)

using System;

class MyAppException : Exception
{
    public MyAppException(string message) : base(message) { }
}

# Your code here

Hint

Both classes inherit from MyAppException and call the base constructor with the message.

3

Write method that throws exceptions

Write a static method called ProcessInput that takes a string input. If input is empty, throw an InputException with message "Input is empty". If input is "error", throw a ProcessingException with message "Processing error occurred". Otherwise, do nothing.

C Sharp (C#)

using System;

class MyAppException : Exception
{
    public MyAppException(string message) : base(message) { }
}

class InputException : MyAppException
{
    public InputException(string message) : base(message) { }
}

class ProcessingException : MyAppException
{
    public ProcessingException(string message) : base(message) { }
}

class Program
{
    static void ProcessInput(string input)
    {
        // Throw exceptions based on input
        # Your code here
    }
}

Hint

Use string.IsNullOrEmpty(input) to check for empty input and throw the correct exceptions.

4

Catch exceptions in order

In the Main method, call ProcessInput three times with inputs: empty string, "error", and "ok". Use a try-catch block to catch exceptions in this order: InputException, ProcessingException, MyAppException, and Exception. Print the caught exception's message with Console.WriteLine. If no exception occurs, print "Input processed successfully".

C Sharp (C#)

using System;

class MyAppException : Exception
{
    public MyAppException(string message) : base(message) { }
}

class InputException : MyAppException
{
    public InputException(string message) : base(message) { }
}

class ProcessingException : MyAppException
{
    public ProcessingException(string message) : base(message) { }
}

class Program
{
    static void ProcessInput(string input)
    {
        if (string.IsNullOrEmpty(input))
        {
            throw new InputException("Input is empty");
        }
        else if (input == "error")
        {
            throw new ProcessingException("Processing error occurred");
        }
    }

    static void Main()
    {
        string[] inputs = { "", "error", "ok" };
        foreach (string input in inputs)
        {
            // Use try-catch to handle exceptions in order
            # Your code here
        }
    }
}

Hint

Remember to catch exceptions from most specific to most general. Print the exception message or success message accordingly.

Practice

1. Which class is the base class for all exceptions in .NET?

easy

A. System.Error

B. System.Exception

C. System.ApplicationException

D. System.SystemException

Solution

1. Step 1: Understand the exception hierarchy

   All exceptions in .NET inherit from a common base class to unify error handling.

2. Step 2: Identify the root base class

   The root base class for all exceptions is System.Exception, from which other exceptions derive.

3. Final Answer:

   System.Exception -> Option B

4. Quick Check:

   Base exception class = System.Exception [OK]

Hint: Remember: All exceptions come from System.Exception [OK]

Common Mistakes:

• Confusing System.SystemException as the base
• Thinking System.ApplicationException is the root
• Assuming System.Error exists in .NET

2. Which of the following is the correct syntax to catch a specific exception type ArgumentNullException in C#?

easy

A. catch (ArgumentNullException e) { }

B. catch ArgumentNullException (e) { }

C. catch (Exception e) { }

D. catch ArgumentNullException { }

Solution

1. Step 1: Recall catch block syntax

   In C#, to catch a specific exception, use catch (ExceptionType variable) syntax.

2. Step 2: Match the correct syntax for ArgumentNullException

   The correct syntax is catch (ArgumentNullException e) { }, which declares the exception type and variable.

3. Final Answer:

   catch (ArgumentNullException e) { } -> Option A

4. Quick Check:

   Correct catch syntax = catch (ExceptionType e) [OK]

Hint: Use parentheses around exception type and variable in catch [OK]

Common Mistakes:

• Omitting parentheses around exception type
• Using wrong order like catch ExceptionType (e)
• Not declaring a variable for the exception

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

try {
    int[] arr = new int[2];
    Console.WriteLine(arr[5]);
} catch (IndexOutOfRangeException e) {
    Console.WriteLine("Index error caught");
} catch (Exception e) {
    Console.WriteLine("General error caught");
}

medium

A. General error caught

B. Compilation error

C. No output, program crashes

D. Index error caught

Solution

1. Step 1: Identify the exception thrown

   Accessing index 5 in an array of size 2 throws IndexOutOfRangeException.

2. Step 2: Check which catch block handles it

   The first catch block specifically catches IndexOutOfRangeException, so it runs and prints "Index error caught".

3. Final Answer:

   Index error caught -> Option D

4. Quick Check:

   Specific catch runs before general [OK]

Hint: Specific exceptions catch before general ones [OK]

Common Mistakes:

• Thinking general Exception catch runs first
• Assuming program crashes without catch
• Confusing IndexOutOfRangeException with ArgumentException

4. Identify the error in this code snippet:

try {
    int x = int.Parse("abc");
} catch (FormatException) {
    Console.WriteLine("Format error");
} catch {
    Console.WriteLine("General error");
}

medium

A. Catch-all block must be last

B. Catch blocks order is incorrect

C. No error, code is correct

D. Missing exception variable in catch blocks

Solution

1. Step 1: Review catch block syntax

   Catch blocks can omit the exception variable if not used, which is valid here.

2. Step 2: Check catch block order

   The specific FormatException catch is before the general catch-all block, which is correct.

3. Final Answer:

   No error, code is correct -> Option C

4. Quick Check:

   Catch-all last and variable optional [OK]

Hint: Catch-all must be last; variable optional in catch [OK]

Common Mistakes:

• Thinking catch-all must have variable
• Placing catch-all before specific catch
• Assuming variable is mandatory in catch

5. You want to catch all exceptions except NullReferenceException and handle them differently. Which approach correctly implements this in C#?

hard

A. Use a catch block for Exception and rethrow if NullReferenceException

B. Use a single catch block for Exception and check exception type inside

C. Use two catch blocks: one for NullReferenceException, one for Exception

D. Use a catch block for NullReferenceException only

Solution

1. Step 1: Understand the requirement

   We want to handle all exceptions except NullReferenceException differently, so we must detect and exclude it.

2. Step 2: Evaluate approaches

   Use a catch block for Exception and rethrow if NullReferenceException uses a general catch for Exception, then rethrows if the exception is NullReferenceException, effectively excluding it from handling.

3. Final Answer:

   Use a catch block for Exception and rethrow if NullReferenceException -> Option A

4. Quick Check:

   Rethrow to exclude specific exceptions [OK]

Hint: Rethrow specific exceptions inside general catch [OK]

Common Mistakes:

• Catching NullReferenceException first but not rethrowing
• Handling all exceptions in one catch without rethrow
• Using only NullReferenceException catch block