Exceptions in C#: Types, Handling, Best Practices, Pros and Cons

An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. Exceptions are used to handle errors and other unusual situations that may arise during the execution of a program.

Table of content

[–]

What are exceptions?

In C# programming language, exceptions are represented by special objects created and thrown when an exceptional situation occurs. These objects contain information about the error or unusual situation, such as a description of the problem and its location in the code.

Exceptions can be caught and handled by the code that is executing. This allows the program to recover from the error and continue running, rather than crashing or producing incorrect results.

For example, if a program is trying to open a file and the file does not exist, an exception may be thrown to indicate that the file could not be found. The code that is executing can catch this exception and display an error message to the user, or take some other appropriate action.

What are System Exceptions and Application Exceptions?

In C# (and in many other programming languages), there are two main types of exceptions: system exceptions and application exceptions.

System exceptions are exceptions that are generated by the system, such as the .NET runtime or the operating system. These exceptions are typically severe errors that cannot be handled by the application and may cause it to crash. Examples of system exceptions include System.IO.IOException, System.IndexOutOfRangeException, and System.NullReferenceException.

Application exceptions are exceptions that are specific to an application or a domain. These exceptions are typically used to handle errors or unusual situations that are specific to the application or domain. Application exceptions are usually derived from the System.Exception class and may have additional properties or methods to provide more information about the exception.

CSharp exceptions class hierarchy — C# Exception Basic Hierarchy

It is generally a good idea to use application exceptions for errors and unusual situations that can be handled by the application and to leave system exceptions to be handled by the system. This can help to improve the stability and reliability of your code and make it easier to debug and maintain.

Few built-in exception classes representing common errors

In C#, exceptions are represented by objects that are derived from the System.Exception class. C# includes several built-in exception classes that represent common error conditions, such as:

System.IO.IOException: This exception is thrown when an I/O error occurs, such as when a file cannot be read or written.
System.IndexOutOfRangeException: This exception is thrown when an array index is out of bounds.
System.DivideByZeroException: This exception is thrown when an attempt is made to divide a number by zero.
System.NullReferenceException: This exception is thrown when an attempt is made to access an object that is null.
System.ArgumentException: This exception is thrown when an invalid argument is passed to a method.

In addition to these built-in exception classes, you can also create your own custom exception classes by deriving from the System.Exception class and adding any necessary properties or methods.

C# also includes a special System.Exception class called System.SystemException represents exceptions that are generated by the system. These exceptions are typically severe errors that cannot be handled by the application and may cause it to crash.

What is the building block of exception and exception handling?

In C# (and in many other programming languages), exceptions are typically implemented using the following building blocks:

Exception class: This is a class that represents a specific type of exception. An exception class typically derives from the System.Exception class and may have additional properties or methods to provide more information about the exception.
Throw statement: This is a statement that creates an exception object and throws it. The throw statement typically appears in a try block and is used to signal that an exceptional situation has occurred.
Try-catch block: This is a block of code that surrounds a section of code that may throw an exception. The try block contains the code that may throw an exception, and the catch block contains the code that handles the exception.
Finally block: This is an optional block of code that follows the try-and-catch blocks. The finally block is always executed, regardless of whether an exception was thrown or caught. It is typically used to clean up resources, such as closing file handles or releasing memory.

Here is an example of how these building blocks can be used in C# to handle an exception:

try
{
    // Code that may throw an exception
}
catch (MyCustomException ex)
{
    // Code to handle the exception
}
finally
{
    // Code to clean up resources
}

In this example, the code in the try block is executed. If an exception is thrown, control is transferred to the catch block, which handles the exception. After the catch block has finished executing, the finally block is executed to clean up any resources that were used. If no exception is thrown, the catch block is skipped and the finally block is still executed.

C#: Example of handling an exception

Here is an example of how to handle an exception in C#:

try
{
    // Code that may throw an exception
    int x = 5;
    int y = 0;
    int z = x / y;
}
catch (DivideByZeroException ex)
{
    // Code to handle the DivideByZeroException
    Console.WriteLine("An error occurred: Cannot divide by zero.");
}
finally
{
    // Code to clean up resources
    Console.WriteLine("Finally block executed.");
}

In this example, the code in the try block attempts to divide x by y, which is zero. This will cause a DivideByZeroException to be thrown. The catch block catches this exception and displays an error message to the user. The finally block is then executed to clean up any resources that were used.

If the code in the try block executes without throwing an exception, the catch block will be skipped and the finally block will still be executed.

What are the important properties of the Exception class?

The System.Exception class, which is the base class for all exceptions in C#, has several important properties that you can use to get information about an exception. Here are some of the most important properties:

Message: The Message property contains a string that describes the error or exception that occurred. This property is typically used to display a user-friendly error message to the user.
StackTrace: The StackTrace property contains a string that represents the call stack at the time the exception was thrown. It includes the method names, file names, and line numbers of each method call in the stack. This property is typically used for debugging purposes to help identify the location in the code where the exception occurred.
InnerException: The InnerException property contains a reference to the inner exception that caused the current exception. If an exception is thrown as a result of another exception, the inner exception can be accessed through the InnerException property. This can be helpful for identifying the root cause of an exception.
HelpLink: The HelpLink property contains a URL or file path that points to a help file or documentation related to the exception. This property can be used to provide additional information or assistance to the user.

By using these properties, you can get more information about an exception and use it to handle the exception more effectively.

How to create a custom exception and use it?

To create a custom exception in C#, you can create a class that derives from the System.Exception class and add any necessary properties or methods.

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

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

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

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

In this example, the MyCustomException class derives from the System.Exception class and has three constructors: one with no arguments, one that takes a message string, and one that takes a message string and an inner exception.

To use the custom exception, you can throw it using the throw statement and catch it using a catch block:

try
{
    // Code that may throw an exception
    throw new MyCustomException("An error occurred.");
}
catch (MyCustomException ex)
{
    // Code to handle the MyCustomException
    Console.WriteLine(ex.Message);
}

In this example, the code in the try block throws a MyCustomException with a message. The catch block catches the exception and displays the message to the user.

You can also include additional properties or methods in your custom exception class to provide more information about the exception. For example, you might add a Code property to represent an error code, or a Details property to contain additional information about the error.

A practical example of a custom exception

Here is a practical example of using a custom exception in C#:

Suppose you are writing a program to validate user input and you want to create a custom exception to handle invalid input. You can create a custom exception class called InvalidInputException like this:

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

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

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

Then, you can use the custom exception in your validation code like this:

string userInput = Console.ReadLine();

try
{
    // Validate the user input
    if (string.IsNullOrWhiteSpace(userInput))
    {
        throw new InvalidInputException("Input cannot be empty.");
    }
}
catch (InvalidInputException ex)
{
    // Code to handle the InvalidInputException
    Console.WriteLine(ex.Message);
}

In this example, the code in the try block checks if the user input is null or consists only of white space characters. If it is, it throws an InvalidInputException with a message. The catch block catches the exception and displays the message to the user.

If the user input is valid, the exception is not thrown and the catch block is skipped.

How to catch multiple exceptions example

Here is a practical example of catching multiple exceptions in C#:

try
{
    // Code that may throw an exception
    string filePath = "C:\myfile.txt";
    string[] lines = File.ReadAllLines(filePath);
    int index = lines.Length + 1;
    string line = lines[index];
}
catch (FileNotFoundException ex)
{
    // Code to handle a FileNotFoundException
    Console.WriteLine("File not found: " + ex.Message);
}
catch (IndexOutOfRangeException ex)
{
    // Code to handle an IndexOutOfRangeException
    Console.WriteLine("Invalid index: " + ex.Message);
}
catch (Exception ex)
{
    // Code to handle any other exception
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    // Code to clean up resources
}

In this example, the code in the try block reads the lines of a file at the specified file path using the File.ReadAllLines method. It then tries to access a line at a specific index using the lines array.

If the file at the specified file path does not exist, the File.ReadAllLines method will throw a FileNotFoundException. If the index is out of range of the lines array (for example, if it is larger than the number of lines in the file), an IndexOutOfRangeException will be thrown.

The catch blocks are used to handle these exceptions. The first catch block handles a FileNotFoundException and displays a message to the user indicating that the file was not found. The second catch block handles an IndexOutOfRangeException and displays a message to the user indicating that the index is invalid. The third catch block handles any other exception that may be thrown and displays a generic error message.

Finally, the code in the finally block is executed to clean up any resources that were used. This block is always executed, regardless of whether an exception was thrown or caught.

By using multiple catch blocks, the code is prepared to handle a variety of exceptions that may occur when reading the lines of a file and accessing a specific line. This helps to improve the reliability and stability of the code.

What are the advantages of handling an exception?

There are several advantages to handling exceptions in your code:

Preventing crashes: Exceptions can be used to prevent your program from crashing when an error or unusual situation occurs. By catching and handling exceptions, you can recover from the error and allow your program to continue running, rather than crashing or producing incorrect results.
Improving reliability: Handling exceptions can improve the reliability of your code by allowing it to gracefully handle and recover from errors and unusual situations. This can help prevent bugs and other issues from occurring and make your code more robust and reliable.
Providing user-friendly error messages: By catching and handling exceptions, you can display user-friendly error messages to the user that explain what went wrong and suggest possible solutions. This can make your program more user-friendly and easier to use.
Debugging: Exceptions can provide valuable information about what went wrong in your code, such as the type of exception that occurred and the location in the code where it occurred. This can make it easier to diagnose and fix problems in your code.

By handling exceptions, you can improve the stability and reliability of your code, and make it more user-friendly and easier to debug.

What are the disadvantages of using an exception?

There are a few potential disadvantages to using exceptions in your code:

Performance overhead: Throwing and catching exceptions can have a performance overhead, especially if they are used frequently. This can make your code run slower and consume more resources.
Complicated error handling: Exception handling can make your code more complex, especially if you are dealing with multiple types of exceptions and have to write complex try-catch blocks. This can make your code harder to read and understand.
Unclear error handling: If exceptions are not properly handled, it can be difficult to understand what went wrong in your code and how to fix it. This can make it harder to debug and maintain your code.
Misuse: Exceptions should be used for exceptional situations, such as errors or unusual conditions that cannot be handled in any other way. If exceptions are used for normal control flow, it can make your code harder to understand and maintain.

Overall, it is important to use exceptions judiciously and handle them properly to avoid these disadvantages.

Summary

Exceptions are events that occur during the execution of a program and disrupt the normal flow of instructions. They are used to handle errors and other unusual situations that may arise during the execution of a program.

In C#, exceptions are represented by objects that are derived from the System.Exception class. There are two main types of exceptions: system exceptions, which are generated by the system and cannot be handled by the application, and application exceptions, which are specific to an application or domain and can be handled by the application.

To handle exceptions in C#, you can use try-catch blocks and a finally block. The try block contains the code that may throw an exception, the catch block contains the code that handles the exception, and the finally block contains code that is always executed, regardless of whether an exception was thrown or caught.

It is important to use exceptions judiciously and handle them properly to avoid performance overhead and improve the stability and reliability of your code. You can create your own custom exception classes by deriving from the System.Exception class and adding any necessary properties or methods. More details can be found on Microsoft Documentation.

I hope you find this post helpful, Cheers!!!

[Further Readings: A Comprehensive Guide to Dependency Injection in C#: Advantages, Disadvantages, Types, and Best Practices | The Ultimate Guide to Text Editors: Types, Features, and Choosing the Best One for You | The top web frameworks to learn in 2023 | Top 7 Web Frameworks to Learn and Focus on in 2021 | Top 7 Programming Languages to Focus on in 2021 | Structural Design Patterns | Bridge Design Pattern in C# | Decorator Design Pattern in C# | Flyweight Design Pattern in C# | Composite Design Pattern in C# | Facade Design Pattern in C# | Proxy Design Pattern in C# | SQLite Studio to manage SQLite databases | Adapter Design Pattern in C# | How to use Blazor EditForm for Model Validation | How to add a new profile in Windows Terminal | How to easily Customize Global Settings in Windows Terminal ]

0 0 votes

Article Rating