User Defined Exception in C# - Create Custom Exceptions Easily
🎯 Introduction
Imagine Emma managing a library system. 📚 She wants to make sure no one borrows more than 5 books at a time. What if someone tries to borrow 10? Emma needs a special alert for that. Unfortunately, built-in exceptions don’t cover such specific rules. That’s when user defined exceptions in C# come to the rescue! 🦸♀️
Sometimes, your program faces problems that standard exceptions just can’t describe. In such cases, creating your own custom exceptions lets you handle those situations with style and precision. Cool, right? 😎 Let’s explore how you can be the boss of your errors!
📚 What You Are Going to Learn in This Lesson
✔️ What is a user defined exception in C#?
✔️ Why and when should you use custom exceptions?
✔️ How to create and throw your own exceptions.
✔️ Real-world examples with complete code and outputs.
✔️ Fun and interactive explanations to make learning easy! 🎉
📝 What is a User Defined Exception in C#?
A user defined exception in C# (also called a C# custom exception) is a special error you create to handle situations not covered by built-in exceptions.
Think of it like this: You know your program better than anyone. If you see a specific condition that should raise a red flag, you create your own exception! 🚩
🖥️ Syntax to Create a User Defined Exception
Here’s how you define your custom exception:
public class MyCustomException : Exception
{
public MyCustomException(string message) : base(message)
{
}
}
💡 Explanation:
MyCustomException: Name of your custom exception class.: Exception: Inherits from the built-inExceptionclass.base(message): Passes your custom message to the baseExceptionclass.
🛠️ Example 1: Simple Custom Exception
✅ Scenario: Oliver wants a program that stops users from entering negative ages.
using System;
public class NegativeAgeException : Exception
{
public NegativeAgeException(string message) : base(message) { }
}
public class Program
{
public static void Main()
{
Console.Write("Enter your age: ");
int age = int.Parse(Console.ReadLine());
if (age < 0)
throw new NegativeAgeException("Age cannot be negative!");
Console.WriteLine($"Your age is {age}.");
}
}
🖨️ Output:
Enter your age: -5
Unhandled exception. NegativeAgeException: Age cannot be negative!
🔍 Explanation:
When the user enters -5, the code throws NegativeAgeException. Without it, the program wouldn’t alert the user in a friendly way. This shows how helpful custom exceptions are! 😃
🛠️ Example 2: Real World Scenario - Bank Withdrawal System
✅ Scenario:Sophia wants her banking app to block withdrawals beyond the account balance.
using System;
public class InsufficientBalanceException : Exception
{
public InsufficientBalanceException(string message) : base(message) { }
}
public class BankAccount
{
public double Balance { get; private set; }
public BankAccount(double balance) => Balance = balance;
public void Withdraw(double amount)
{
if (amount > Balance)
throw new InsufficientBalanceException("Insufficient balance!");
Balance -= amount;
Console.WriteLine($"Withdrawal successful! New balance: ${Balance}");
}
}
public class Program
{
public static void Main()
{
BankAccount account = new BankAccount(1000);
Console.WriteLine($"Current balance: ${account.Balance}");
Console.Write("Enter withdrawal amount: ");
double amount = double.Parse(Console.ReadLine());
account.Withdraw(amount);
}
}
🖨️ Output:
Current balance: $1000
Enter withdrawal amount: 1500
Unhandled exception. InsufficientBalanceException: Insufficient balance!
🔍 Explanation:
When the user tries to withdraw $1500, the InsufficientBalanceException is triggered. Without this check, users could overdraw their accounts. 🚫💸
🛠️ Example 3: Student Grade Validation
✅ Scenario:Noah wants to ensure grades are between 0 and 100.
using System;
public class InvalidGradeException : Exception
{
public InvalidGradeException(string message) : base(message) { }
}
public class Student
{
public void SetGrade(int grade)
{
if (grade < 0 || grade > 100)
throw new InvalidGradeException("Grade must be between 0 and 100.");
Console.WriteLine($"Grade set to: {grade}");
}
}
public class Program
{
public static void Main()
{
Student student = new Student();
Console.Write("Enter student grade: ");
int grade = int.Parse(Console.ReadLine());
student.SetGrade(grade);
}
}
🖨️ Output:
Enter student grade: 105
Unhandled exception. InvalidGradeException: Grade must be between 0 and 100.
🔍 Explanation:
Grades like 105 aren’t valid. Noah’s custom exception makes sure no such mistakes slip through! 📝✅
🛠️ Example 4: Parking Lot Capacity Check
✅ Scenario:Liam manages a parking lot with a max capacity of 50 cars. No more should enter when full.
using System;
public class ParkingFullException : Exception
{
public ParkingFullException(string message) : base(message) { }
}
public class ParkingLot
{
public int Capacity { get; }
public int CarsParked { get; private set; }
public ParkingLot(int capacity) => Capacity = capacity;
public void ParkCar()
{
if (CarsParked >= Capacity)
throw new ParkingFullException("Parking lot is full!");
CarsParked++;
Console.WriteLine($"Car parked! Total cars: {CarsParked}");
}
}
public class Program
{
public static void Main()
{
ParkingLot lot = new ParkingLot(2);
try
{
lot.ParkCar(); // 1st car
lot.ParkCar(); // 2nd car
lot.ParkCar(); // 3rd car throws exception
}
catch (ParkingFullException ex)
{
Console.WriteLine(ex.Message);
}
}
}
🖨️ Output:
Car parked! Total cars: 1
Car parked! Total cars: 2
Parking lot is full!
🔍 Explanation:
When the third car tries to park, the ParkingFullException prevents overcrowding. 🅿️🚗🚫
🏆 Conclusion
You’ve just unlocked the power of user defined exceptions in C#! 🚀 Creating custom exceptions allows you to handle unique problems with clarity. Whether it’s controlling library books, managing bank withdrawals, or preventing parking chaos, you’re now ready to make your programs smarter and safer. 🛡️
👉 Next what?
Excited to take your exception-handling skills further? 😃 In the next chapter, you’ll learn about nested & multiple catch in C#. It’s like having multiple safety nets for different types of errors! Stay tuned—your C# journey just keeps getting better! 🎉🔥
