How to create custom exceptions in C #

Who the article is written for

This article is intended primarily for beginners in the .NET world, but it can also be useful for developers with experience who have not fully figured out how to properly build their user-defined exceptions using C #.

Sample code for this article can be downloaded here .

Create a simple exception

It is recommended to create your own exception types in C # in those cases when you need to clearly separate the exception that has arisen in the code written by the programmer from the exception that occurs in the standard .NET Framework types.

For example, there is a method designed to change the username:

private static void EditUser(string oldUserName, string newUserName)
{
    var userForEdit = GetUserByName(oldUserName);
        if (userForEdit == null) 
            return;
        else
            userForEdit.Name = newUserName;
}

This method will solve the tasks assigned to it, but will not do one important thing - it will not report that the user with the given name is missing, and the operation of changing his name has not been performed.

To inform about an exceptional situation, you can generate a standard exception, which is not the recommended practice:

private static void EditUser(string oldUserNane, string newUserName)
{
    var userForEdit = GetUserByName(oldUserName);
        if(userForEdit == null) 
            throw new Exception();
        else
            userForEdit.Name = newUserName;
}

In order to be able to easily determine that an exception is generated at the specific application level, you need to create your own - a custom Exception, and when you get null, throw it in place of the right user.

Creating your own Exception is not difficult - you need to define a public class that will inherit from System.Exception or System.ApplicationException . Although this is not good practice, you can omit the code inside the generated exception class at all:

public class UserNotFoundException : ApplicationException
{
}

Now, instead of Exception, we will raise the UserNotFoundException that we created:

private static void EditUser(string oldUserNane, string newUserName)
{
    var userForEdit = GetUserByName(oldUserName);
    if(userForEdit == null) throw new UserNotFoundException();
    else
        userForEdit.Name = newUserName;
}

In this case, the message about the exception will be: “Error in the application.” . Which is not very informative.

In order for custom exception class code to comply with .NET guidelines, the following rules must be followed :

• the exception class must inherit from Exception / ApplicationException;
• the class must be marked with the [System.Serializable] attribute;
• the class must define a standard constructor;
• the class must define a constructor that sets the value of the inherited Message property;
• the class must define a constructor to handle “internal exceptions”;
• the class must define a constructor to support type serialization.

A little about the purpose of individual constructors: a constructor for handling “internal exceptions” is needed in order to pass an exception into it, which caused this exception. For more details, why do we need a constructor to support type serialization under the spoiler “Adding additional fields, their serialization and deserialization” below.

In order to save the programmer from having to write the same code in Visual Studio, there is an Exception snippet that generates an exception class that meets all the recommendations listed above.



So, after implementing the recommendations, the code of our exception should look something like this:

public class UserNotFoundException : ApplicationException
    {
        public UserNotFoundException() { }
        public UserNotFoundException(string message) : base(message) { }
        public UserNotFoundException(string message, Exception inner) : base(message, inner) { }
        protected UserNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) { }
    }

Now, when throwing an exception, we can indicate the reason for its occurrence in more detail:

throw new UserNotFoundException("User \"" + oldUserName + "\" not found in system");

And the last touch - adding to the XML documentation (if you, of course, use it) of our method of information that it can throw an exception of a certain type:

/// 

So, our user-defined exception is ready for use. You can add to it whatever your heart desires: additional fields describing the exception state, containing additional information, etc.

PS: Added information on how to serialize and deserialize additional fields of the exception class. Details under the spoiler "Adding additional fields, their serialization and deserialization . "

PPS: Thank you for your comments and healthy criticism. Those who read the article to the end - read also the comments, there is useful information.