Custom exception classes in C Sharp (C#) - Mini Project: Build & Apply

Custom Exception Classes in C#

📖 Scenario: Imagine you are building a simple banking application. You want to handle errors clearly when someone tries to withdraw more money than they have in their account.

🎯 Goal: You will create a custom exception class called InsufficientFundsException to represent this specific error. Then, you will use this exception in a method that withdraws money from an account.

📋 What You'll Learn

Create a custom exception class named InsufficientFundsException that inherits from Exception.

Add a constructor to InsufficientFundsException that takes a string message and passes it to the base Exception class.

Create a variable balance of type decimal with the value 1000m.

Create a variable withdrawAmount of type decimal with the value 1500m.

Write an if statement to check if withdrawAmount is greater than balance and throw InsufficientFundsException with the message "Not enough money in the account.".

Write a try-catch block to catch InsufficientFundsException and print the exception message.

💡 Why This Matters

🌍 Real World

Custom exceptions help you handle specific errors in your programs clearly, like when a bank account has insufficient funds.

💼 Career

Understanding custom exceptions is important for writing robust, maintainable code in professional software development.

1

Create the custom exception class

Create a public class called InsufficientFundsException that inherits from Exception. Add a constructor that takes a string parameter message and passes it to the base Exception constructor using base(message).

C Sharp (C#)

// Your code here

Hint

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

2

Set up account balance and withdrawal amount

Create a decimal variable called balance and set it to 1000m. Create another decimal variable called withdrawAmount and set it to 1500m.

C Sharp (C#)

using System;

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

// Your code here

Hint

Use decimal type and remember the m suffix for decimal literals.

3

Throw the custom exception when withdrawal is too large

Inside the Main method, write an if statement that checks if withdrawAmount is greater than balance. If true, throw a new InsufficientFundsException with the message "Not enough money in the account.".

C Sharp (C#)

using System;

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

class Program
{
    static void Main()
    {
        decimal balance = 1000m;
        decimal withdrawAmount = 1500m;

        // Your code here
    }
}

Hint

Use throw new InsufficientFundsException("message") inside the if block.

4

Catch and display the custom exception message

Wrap the if statement inside a try block. Add a catch block that catches InsufficientFundsException as ex and prints ex.Message using Console.WriteLine.

C Sharp (C#)

using System;

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

class Program
{
    static void Main()
    {
        decimal balance = 1000m;
        decimal withdrawAmount = 1500m;

        // Your code here
    }
}

Hint

Use try and catch (InsufficientFundsException ex) to handle the exception and print ex.Message.

Practice

1. What is the main reason to create a custom exception class in C#?

easy

A. To automatically fix errors when they occur

B. To make the program run faster

C. To avoid using try-catch blocks

D. To represent specific error conditions clearly in your program

Solution

1. Step 1: Understand the purpose of exceptions

   Exceptions represent errors or unexpected situations in a program.

2. Step 2: Identify why custom exceptions are used

   Custom exceptions help describe specific problems clearly, making error handling easier and more meaningful.

3. Final Answer:

   To represent specific error conditions clearly in your program -> Option D

4. Quick Check:

   Custom exceptions clarify errors = A [OK]

Hint: Custom exceptions explain specific errors clearly [OK]

Common Mistakes:

• Thinking custom exceptions improve speed
• Believing they remove need for try-catch
• Assuming they fix errors automatically

2. Which of the following is the correct way to declare a custom exception class named MyException in C#?

easy

A. class MyException : Exception { public MyException(string message) : base(message) {} }

B. class MyException { public MyException(string message) {} }

C. class MyException : int { public MyException(string message) : base(message) {} }

D. class MyException : Exception { public void MyException(string message) {} }

Solution

1. Step 1: Check inheritance from Exception

   Custom exceptions must inherit from Exception to behave like exceptions.

2. Step 2: Verify constructor calls base constructor

   The constructor should call base(message) to pass the error message properly.

3. Final Answer:

   class MyException : Exception { public MyException(string message) : base(message) {} } -> Option A

4. Quick Check:

   Inherit Exception + call base constructor = A [OK]

Hint: Inherit Exception and call base constructor for message [OK]

Common Mistakes:

• Not inheriting from Exception
• Using wrong base class like int
• Defining constructor as void method

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

class MyException : Exception { public MyException(string message) : base(message) {} }
try {
  throw new MyException("Error happened");
} catch (MyException ex) {
  Console.WriteLine(ex.Message);
}

medium

A. Exception caught

B. Error happened

C. MyException

D. No output

Solution

1. Step 1: Understand the throw statement

   The code throws a MyException with message "Error happened".

2. Step 2: Catch block prints exception message

   The catch block catches MyException and prints ex.Message, which is "Error happened".

3. Final Answer:

   Error happened -> Option B

4. Quick Check:

   Throw and catch prints message = C [OK]

Hint: Catch prints exception message property [OK]

Common Mistakes:

• Expecting class name instead of message
• Thinking catch block won't run
• Assuming no output from exception

4. Identify the error in this custom exception class declaration:

class MyError : Exception {
  public MyError(string msg) {
    base(msg);
  }
}

medium

A. The class must not inherit from Exception

B. The constructor should be named differently from the class

C. The constructor should call base(msg) using a colon, not inside the body

D. The base class Exception does not accept a string parameter

Solution

1. Step 1: Check constructor syntax for base call

   In C#, calling the base class constructor must be done with a colon after the constructor signature, not inside the body.

2. Step 2: Identify correct syntax

   The correct syntax is public MyError(string msg) : base(msg) {}, not calling base(msg); inside the constructor body.

3. Final Answer:

   The constructor should call base(msg) using a colon, not inside the body -> Option C

4. Quick Check:

   Base constructor call uses colon syntax = B [OK]

Hint: Call base constructor with colon, not inside method body [OK]

Common Mistakes:

• Calling base constructor inside body instead of colon
• Not inheriting from Exception
• Misnaming constructor

5. You want to create a custom exception InvalidAgeException that should be thrown when a user's age is less than 0 or greater than 120. Which of the following code snippets correctly defines and uses this exception?

hard

A. class InvalidAgeException : Exception { public InvalidAgeException(string msg) : base(msg) {} }void CheckAge(int age) { if(age < 0 || age > 120) throw new InvalidAgeException("Age is invalid"); }

B. class InvalidAgeException { public InvalidAgeException(string msg) {} }void CheckAge(int age) { if(age < 0 || age > 120) throw new InvalidAgeException("Age is invalid"); }

C. class InvalidAgeException : Exception { public void InvalidAgeException(string msg) {} }void CheckAge(int age) { if(age < 0 || age > 120) throw new InvalidAgeException("Age is invalid"); }

D. class InvalidAgeException : Exception { public InvalidAgeException() {} }void CheckAge(int age) { if(age < 0 || age > 120) throw new InvalidAgeException(); }

Solution

1. Step 1: Verify custom exception class definition

   The class inherits from Exception and has a constructor calling base(msg) to pass the message.

2. Step 2: Check usage in method

   The method throws the exception with a message when age is invalid, which matches the requirement.

3. Final Answer:

   Correct class inheritance, constructor, and usage with message -> Option A

4. Quick Check:

   Inherit Exception + throw with message = D [OK]

Hint: Inherit Exception, add constructor, throw with message [OK]

Common Mistakes:

• Not inheriting from Exception
• Defining constructor as void method
• Missing message in exception constructor