Custom Exceptions | Error Handling

Introduction

Error handling is a critical aspect of robust software development. In C#, exceptions provide a structured way to handle errors. While .NET provides numerous built-in exceptions, there are scenarios where custom exceptions are necessary to represent specific error conditions in your application. This tutorial will guide you through creating and using custom exceptions in C#.

Why Use Custom Exceptions?

Custom exceptions are used to:

Provide more meaningful error messages.
Encapsulate specific error details related to the application domain.
Enable error handling at different levels of your application.

Creating a Custom Exception

To create a custom exception, you need to inherit from the System.Exception class or one of its derived classes. Here is a simple example:


using System;

public class InvalidAgeException : Exception
{
    public InvalidAgeException() : base("Invalid age specified.")
    {
    }

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

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

In this example, we have created a custom exception called InvalidAgeException that has multiple constructors for flexibility.

Throwing a Custom Exception

Once you have defined a custom exception, you can throw it using the throw keyword:


public class Person
{
    public int Age { get; set; }

    public void SetAge(int age)
    {
        if (age < 0 || age > 150)
        {
            throw new InvalidAgeException("Age must be between 0 and 150.");
        }
        Age = age;
    }
}

In this example, we have a Person class with a method SetAge that throws an InvalidAgeException if the age is not within the valid range.

Handling a Custom Exception

Custom exceptions can be caught and handled just like any other exception:


public class Program
{
    public static void Main()
    {
        Person person = new Person();
        try
        {
            person.SetAge(200);
        }
        catch (InvalidAgeException ex)
        {
            Console.WriteLine("Caught an exception: " + ex.Message);
        }
    }
}

In this example, the InvalidAgeException is caught in a catch block, and an appropriate message is displayed.

Best Practices for Custom Exceptions

When creating custom exceptions, consider the following best practices:

Always derive from System.Exception or a subclass of it.
Provide multiple constructors to offer flexibility.
Use meaningful exception names that convey the error condition.
Include detailed error messages.
Consider implementing serialization if the exception needs to be transferred across application domains.

Conclusion

Custom exceptions are a powerful tool for handling specific error conditions in your application. By following best practices and providing meaningful error messages, you can make your application more robust and easier to debug. We hope this tutorial has helped you understand how to create and use custom exceptions in C#.

Custom Exceptions in C#