How to create custom exceptions in C #

For whom the article is written

This article is primarily intended for newcomers to 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 .

Creating a simple exception

It is recommended to create your own types of exceptions in C # in cases when you need to clearly separate the exception that occurred in the programmer’s written code 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 it will not do one important thing - it will not report that the user with the specified name is missing and the operation to change his name has not been performed.

To inform about the occurrence of an exceptional situation, you can generate a standard exception, which is not a 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 level of a specific application, you need to create your own - custom Exception, and when you receive null, throw it instead of the desired 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 a good practice, the code inside the created exception class can be omitted at all:

 public class UserNotFoundException : ApplicationException { } 

Now, instead of Exception, we will generate the UserNotFoundException 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, as a message on the occurrence of the exception will be: "Error in the application." . What is not very informative.

In order for the custom exception class code to comply with the .NET recommendations, you need to adhere to the following rules :

• the exception class must inherit from Exception / ApplicationException;
• class must be marked with attribute [System.Serializable];
• 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 into it an exception that caused the exception. In more detail, why is a constructor needed 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 a “Exception” snippet that generates an exception class that complies with all the recommendations listed above.



So, after implementing the recommendations, the code for our exception should look 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 generating an exception, we can specify the reason for its occurrence in more detail:

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

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

 /// <exception cref="UserDefinedException.UserNotFoundException" /> 

So, our user-defined exception is ready to use. You can add to it everything your heart desires: additional fields describing the state of exclusion, 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. For those who read the article to the end - read also the comments, there is useful information.