C# Custom Exceptions: Complete Guide [2023]

Create a custom exception in C#

In C#, you can create custom exceptions by creating a new class that derives from the Exception class. The custom exception class can also have additional properties or methods that you need.

Here is an example of how you could create a custom exception class in C#:

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

This custom exception class above represents a condition where the user has provided invalid input. The class derives from the built-in Exception class and adds a few additional constructors to make it easier to create the exception.

Here is an example of how to throw and catch this custom exception:

try
{
    // code that might throw an exception
    if (inputIsInvalid)
    {
        throw new InvalidInputException("The input is invalid!");
    }
}
catch (InvalidInputException ex)
{
    // handle the exception
    Console.WriteLine(ex.Message);
}

In this example, the try block contains code that might throw an InvalidInputException if the input is invalid. If the exception is thrown, it is caught in the catch block and the error message is printed to the console.

Custom Exceptions Best Practices

Here are a few things to keep in mind when creating custom exceptions in C#:

1. Create a separate exception class for each error condition that you want to handle. This makes it easier to identify and handle specific exceptions in your code.

2. Override the Message property to provide a meaningful error message that describes the error condition. This message will be displayed when the exception is thrown.

3. Override the ToString() method to return a string representation of the exception, which can be useful for logging and debugging purposes.

4. Add additional properties or methods that you need to your custom exception class to provide more information about the error condition.

What to avoid when creating custom exceptions in C#?

Here are a few things to avoid when working with custom exceptions in C#:

1. Avoid creating too many custom exception classes. It is a good idea to create a separate exception class for each error condition that you want to handle, but you should try to keep the number of exception classes to a minimum. Having too many exception classes can make your code more difficult to understand and maintain.

2. Avoid throwing exceptions for expected error conditions. Exceptions are intended to handle unexpected error conditions, not to control the normal flow of your code. If you have an error condition that you expect to occur under certain circumstances, it is better to handle it using normal control flow statements like if and else rather than throwing an exception.

3. Avoid catching and ignoring exceptions. If you catch an exception, you should take some action to handle the error condition. Ignoring exceptions can cause problems in your code and make it difficult to track down and fix bugs.

4. Avoid catching the base Exception class. The Exception class is the base class for all exceptions in C#, and catching this class will catch all exceptions, including those that you might not be prepared to handle. Instead, you should catch specific exception types that you are prepared to handle.

Custom Exception Performance

Using custom exceptions in C# should not have a significant impact on the performance of your code. Throwing and catching exceptions can be somewhat slower than normal control flow statements like if and else, but the difference is usually small and should not be a concern unless you are writing code that needs to be extremely high performance.

In general, the benefits of using custom exceptions far outweigh any potential performance issues. Custom exceptions can help you write more organized and maintainable code by providing a clear and concise way to represent and handle error conditions.

Custom Exception examples

Custom exception class with custom properties

Here is an example of a custom exception class that includes custom properties:

public class InvalidInputException : Exception
{
    public string InvalidInput { get; }

    public InvalidInputException(string message, string invalidInput) : base(message)
    {
        InvalidInput = invalidInput;
    }
}

This custom exception class represents an error condition where the user has provided invalid input. The class includes a custom property called InvalidInput that stores the invalid input that caused the exception.

Here is an example of how you could throw and catch this custom exception:

try
{
    // code that might throw an exception
    if (inputIsInvalid)
    {
        throw new InvalidInputException("The input is invalid!", invalidInput);
    }
}
catch (InvalidInputException ex)
{
    // handle the exception
    Console.WriteLine(ex.Message);
    Console.WriteLine("Invalid input: " + ex.InvalidInput);
}

In this example, the try block contains code that might throw an InvalidInputException if the input is invalid. If the exception is thrown, it is caught in the catch block and the error message and invalid input are printed to the console.

Most important terms

FAQ: Custom Exceptions

Here are a few frequently asked questions about custom exceptions in C#:

throw new InvalidInputException("The input is invalid!");

try
{
    // code that might throw an exception
}
catch (InvalidInputException ex)
{
    // handle the exception
}

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