Custom Exceptions in C#

---

---

In C# programming, an exception refers to an error that occurs during the execution of a program. However, in real-world applications, sometimes the built-in exceptions are not enough to clearly describe the problem; that is why we need to use custom exceptions. They are also called user-defined exceptions.

A custom exception allows us to define and manage application-specific errors in a clearer, more meaningful, and controlled way.

What is a Custom Exception in C#?

A custom exception is a user-defined class that inherits from the base System.Exception class (or a derived class). It enables developers to handle application-specific errors robustly and in a structured way.

How to Create a Custom Exception in C#

To create a custom exception class in C#, follow these steps −

• Create a new class that inherits from the Exception class.
• Define constructors (default, message-based, and with inner exception).
• Add custom properties or methods for additional information. It is optional.
• Use the try, catch and throw keywords to throw and catch the custom exception.

using System;

public class MyCustomException : Exception {
   public MyCustomException() { }

   public MyCustomException(string message)
      : base(message) { }

   public MyCustomException(string message, Exception innerException)
      : base(message, innerException) { }
}

Why Use Custom Exceptions in C#?

We use custom exceptions to create our own exception classes that are helpful when you need to −

• Represent specific business logic errors (e.g., InvalidAge, UserNotFound, LowBalance).
• Make our exception handling more readable and organized.
• Add extra information like error codes, invalid values, or timestamps.
• Differentiate application errors from system errors.
• Provide a consistent exception structure across your application.

Example: Custom Exception in C#

In the following example, we create a user-defined exception for validating a person's age.

using System;

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

class Program {
   static void ValidateAge(int age) {
      if (age < 18){
         throw new InvalidAgeException("Age must be 18 or older to register.");
      }
      Console.WriteLine("Registration successful!");
   }

   static void Main(){
      try {
         ValidateAge(15);
      }
      catch (InvalidAgeException ex) {
         Console.WriteLine($"Custom Exception: {ex.Message}");
      }
   }
}

Following is the output −

Custom Exception: Age must be 18 or older to register.

Example: Adding Custom Properties to Exceptions

We can enhance our custom exception class by adding extra properties such as an error code or the invalid value.

using System;

public class InvalidAgeException : Exception {
   public int AgeValue { get; }
   // adding custom property
   public InvalidAgeException(string message, int age)
      : base(message) {
      AgeValue = age;
   }
}
class Program {
   static void ValidateAge(int age) {
      if (age < 18) {
         throw new InvalidAgeException("You must be 18 or older.", age);
      }
      Console.WriteLine("Age is valid!");
   }

   static void Main() {
      try {
      ValidateAge(15);
      }
      catch (InvalidAgeException ex) {
          Console.WriteLine($"Error: {ex.Message}");
          Console.WriteLine($"Invalid Age Entered: {ex.AgeValue}");
      }
   }
}

Following is the output −

Error: You must be 18 or older.
Invalid Age Entered: 15

C# Custom Exception with Inner Exception

In many situations, one exception can cause another. The InnerException property in C# helps you trace the original error that led to the current exception. It's useful for understanding the root cause of a problem while debugging.

using System;

public class FileProcessingException : Exception {
   public FileProcessingException(string message, Exception inner) : base(message, inner) { }
}

class Program {
   static void ProcessFile(){
      try {
         throw new NullReferenceException("File data is missing.");
      }
      catch (NullReferenceException ex) {
         throw new FileProcessingException("Error while processing the file.", ex);
      }
   }

   static void Main() {
      try {
         ProcessFile();
      }
      catch (FileProcessingException ex){
         Console.WriteLine($"Custom Exception: {ex.Message}");
         Console.WriteLine($"Inner Exception: {ex.InnerException.Message}");
      }
   }
}

Following is the output −

Custom Exception: Error while processing the file.
Inner Exception: File data is missing.

Advantages of Custom Exceptions

Following are the advantages of custom exception −

• Provide clear and specific error messages.
• Help in better debugging and maintenance.
• Improve readability and structure of error-handling code.
• Allow custom logging and error reporting.

Buit-in Exception vs Custom Exception

Following is the difference between built-in and custom exceptions −

Conclusion

Custom exceptions in C# give us advantages to define meaningful, domain-specific errors that make our code cleaner, safer, and easy to debug. It is derived from the exception class, and by using it, we can build robust error-handling systems customized to our application's needs.