Exception handling in C# tutorial |Dot Net Guide Exception Handling in C# |

Exception handling is a crucial aspect of software development, particularly in complex systems and large-scale applications. In C#, exception handling provides a mechanism for handling and managing errors and exceptions that may occur during runtime. This helps to prevent the application from crashing and ensures a more seamless user experience for the end-user. In this article, we will delve into the details of exception handling in C#, how it works, and why it is important.

What is Exception?

An exception is an error or unwanted result in the application. The exceptions are errors that arises during the execution of a program. They can be because of user, logic, or system errors.

There are 2 main types of Exception:

Compile Time Exceptions
Runtime Exceptions

Compile Time Exceptions:

Compile-time exceptions occur due to syntax errors or incorrect syntax codes. These errors can be found at compile time. These errors are easy to find.

Runtime Exceptions:

Runtime exceptions occur at the time of the actual execution of an application. These exceptions occur due to logical errors such as attempting a number to divide by 0 and so on. These exceptions are difficult to predict or find out. But we can control these errors to some extent.

What is Exception Handling in C#?

Exception handling in C# is a mechanism used to handle runtime errors and exceptions. Exceptions are unexpected events that occur during the execution of a program. These events could be anything from a missing file, an invalid argument, or a divide-by-zero error. Exception handling allows the program to continue executing, even when an exception is thrown, by providing a mechanism for capturing the exception and taking appropriate action.

Exceptions offer a way to transfer control from one part of a program to another. C# exception handling is basically built upon four keywords: try, catch, finally, and throw.

try − Try block encloses the block of the code that may cause the program to throw an exception. It is followed by one or more catch blocks.
catch − When we have exceptions in try block then it transfers the control to the catch block to catch the exception. The catch keyword indicates the catching of an exception.
finally − The finally block is used to execute a given set of statements or instructions irrespective of the occurrence of an exception. Finally block is always executed. For example, if you open a file, it must be closed whether an exception is raised or not.
throw − It allows the program to throw an error whenever it encounters one. This is done using a throw keyword.

Syntax:

try {
   // code causing exception
    } 
catch( Exception_Name ex1 ) 
{
      // Exception handling code
} 
catch( Exception_Name ex2 )
 {
   // Exception handling code
 } 
catch( Exception ex ) 
     {
      // Exception handling code
     } 
finally
    {
     // code in this block is always executed
    }

Exception Classes In C#

Exception classes in the C# are basically derived directly or indirectly from the System.Exception class.

Let us have a brief look at some of the most common exceptions:

System.DividedByZeroException: This exception class handles errors thrown when a number is divided by zero.
System.IO.IOException: This exception class handles any input and output-related errors.
System.NullReferenceException: This exception class handles any error that may occur when a null object is referenced.
System.OutOfMemoryException: This exception class handles errors thrown due to insufficient memory presence.
System.IndexOutOfRangeException: This exception class handles the error thrown when a program tries to access an index that is out of range for the array.
System.InvalidCastException: This exception class handles errors generated during typecasting.
System.StackOverflowException: This exception class handles errors generated from stack overflow.
System.ArrayTypeMismatchException: This exception class handles errors generated when the type is mismatched with the array type.

How Exception Handling Works in C#

In C#, exception handling is implemented using the “try-catch-finally” construct. The “try” block contains the code that may throw an exception. The “catch” block contains the code that handles the exception. The “finally” block contains the code that is executed regardless of whether an exception is thrown or not.

Here’s a simple example of how exception handling works in C#:

try
{
   int x= 10;
   int y=0;
   int z = x/y;
}
catch(DivideByZeroEception ex)
{
   Console.WriteLine("Can not Divide by Zero");
}
finally
{
   Console.WriteLine("This code will always be executed");
}

In this example, the “try” block contains the code that attempts to divide x by y. Since y is equal to zero, a DivideByZeroException is thrown. The “catch” block contains the code that handles the exception, in this case, printing a message to the console. The “finally” block contains the code that will always be executed, regardless of whether an exception is thrown or not.

Why is Exception Handling Important in C#?

Exception handling is an essential aspect of software development, particularly in large-scale applications, where unexpected events can occur frequently. Exception handling provides several benefits, including:

Improved User Experience: Exception handling ensures that the application continues to run even when an exception is thrown. This provides a more seamless user experience and helps to prevent the application from crashing.
Debugging and Troubleshooting: Exception handling provides a mechanism for capturing exceptions and logging detailed information about the error. This makes debugging and troubleshooting easier, as developers can quickly identify the root cause of the issue and take appropriate action.
Improved Code Quality: Exception handling helps to maintain the quality of the code by ensuring that exceptions are handled in a consistent and predictable manner. This helps to reduce the risk of bugs and improves the reliability of the application.
Enhanced Security: Exception handling helps to enhance the security of the application by preventing sensitive information from being disclosed to the end user. This is particularly important in applications that handle sensitive data, such as financial or personal information.

In many cases, an exception may be thrown not by a method that your code has called directly, but by another method further down in the call stack. When this happens, the CLR will unwind the stack, looking for a method with a catch block for the specific exception type, and it will execute the first such catch block that it finds. If it finds no appropriate catch block anywhere in the call stack, it will terminate the process and display a message to the user.

Note: The Exception class is a base class for all exceptions.

Common Exceptions

The following table lists some common exceptions with examples of what can cause them.

Exception type	Base Type	Description	Example
Exception	Object	Base class for all exceptions.	None (use a derived class of this exception).
IndexOutOfRangeException	Exception	Thrown by the runtime only when an array is indexed improperly.	Indexing an array outside its valid range: `arr[arr.Length+1]`
NullReferenceException	Exception	Thrown by the runtime only when a null object is referenced.	`object o = null; o.ToString();`
DivideByZeroException	Exception	Thrown by the runtime only when trying to divide a number by 0	int a=12/0;

finally: There is a special block introduced is finally. It is a block that executes compulsorily whether the error is occurring or not. It is executed at last. Generally, finally, block is used for cleaning up the resources or closing the database connection, etc.

try
{
    // This is a block which may contain an error
}
catch
{
    // This block handles the error if the error is thrown by try block
}
finally
{
  // This block always executes.
}

Special Notes:

Exceptions are types that all ultimately derive from System.Exception.
Use a try block around the statements that might throw exceptions.
Once an exception occurs in the try block, the flow of control jumps to the first associated exception handler that is present anywhere in the call stack. In C#, the catch keyword is used to define an exception handler.
If no exception handler for a given exception is present, the program stops executing with an error message.
Do not catch an exception unless you can handle it and leave the application in a known state. If you catch System.Exception, rethrow it using the throw keyword at the end of the catch block.
If a catch block defines an exception variable, you can use it to obtain more information about the type of exception that occurred.
Exceptions can be explicitly generated by a program by using the throw keyword.
Exception objects contain detailed information about the error, such as the state of the call stack and a text description of the error.
Code in a finally block is executed even if an exception is thrown. Use a finally block to release resources, for example to close any streams or files that were opened in the try block.

How to use the try/catch block to catch exceptions

Place the sections of code that might throw exceptions in a try block and place code that handles exceptions in a catch block. The catch block is a series of statements beginning with the keyword catch, followed by an exception type and an action to be taken.

class ExceptionDemo
    {
        public int divide(int x, int y)
        {
          int r=x/y;
            return r;
        }
        static void Main()
        {
          ExceptionDemo ed=new ExceptionDemo();
          int result=0;
            
            try
            {
                result = ed.divide(10, 0);
                Console.Write(result);
            }
            catch (DivideByZeroException e)
            {
                Console.WriteLine("Attempted divide by zero.");
            }
        }
    }

We can also create Custom Exception class as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace user_defined_exception
{
    class Program
    {
        static void Main(string[] args)
        {
            int acceptorder;
            Console.WriteLine("Welcome to Book Store:\nHow many books you want to buy (Total 10 in Stock):");
            acceptorder = Convert.ToInt32(Console.ReadLine());
            try
            {
                if (acceptorder == 10 || acceptorder < 10)
                {
                    Console.WriteLine("Congratulations! You have bought {0} books", acceptorder);
                    Console.ReadLine();
                }
                else
                {
                    throw (new OutofStockException("OutofStockException Generated: The number of item you want to buy is out of stock. Please enter total item number within stock"));
                }
            }
            catch (OutofStockException oex)
            {
                Console.WriteLine(oex.Message.ToString());
                Console.ReadLine();
            }

        }
    }

    //Creating Custome Exception - OutofStockException
    public class OutofStockException : Exception
    {
        public OutofStockException(string message)
            : base(message)
        {
        }
    }
}

Best Practices for Exception Handling in C#

Use Specific Exception Types: When handling exceptions, it is important to use specific exception types, rather than the generic Exception type. This allows you to catch specific exceptions and take appropriate action, rather than just catching all exceptions and ignoring the root cause.

Log Exceptions: It’s a good practice to log exceptions, including the exception type, message, and stack trace, for troubleshooting and debugging purposes. You can use the System.Diagnostics namespace to log exceptions to a file, the event log, or the console.
Avoid Swallowing Exceptions: Avoid swallowing exceptions by not catching exceptions that you cannot handle. This can lead to bugs and make it difficult to troubleshoot issues. Propagate an exception to a higher level of the application if you cannot handle it properly.
Use Exception Filters: Specify conditions that must be met before catching an exception using exception filters. This provides a more fine-grained approach to exception handling and can improve the performance of your application by avoiding unnecessary catch blocks.
Avoid Overusing Exception Handling: Overusing exception handling can make your code more complex and difficult to maintain. Use exception handling only for exceptional cases and not as a way of controlling the flow of your application.
Use Finally Blocks: Finally blocks are useful for releasing resources, such as files or database connections, that need to be cleaned up regardless of whether an exception is thrown or not.
Test Your Exception Handling: Ensure that your exception handling is working as expected by testing your application with various scenarios that can cause exceptions. This will help you catch any bugs and ensure that your exception handling is working properly.

Choosing the Right Exception: It’s important to choose the right exception type to throw in your application. In C#, there are several built-in exception types that you can use, including System.Exception, System.ApplicationException, and System.SystemException. You can also create your own custom exceptions by creating a new class that inherits from System.Exception. When choosing an exception type, consider the nature of the error, the severity of the error, and the type of recovery that is possible.
Exception Propagation: When an exception is thrown, it can be caught and handled by an exception handler in the same method, a catch block in a calling method, or a finally block in a calling method. This process is known as exception propagation. Exception propagation is an important aspect of exception handling and helps ensure that exceptions are handled in a consistent and predictable manner throughout your application.
Custom Exceptions: In addition to the built-in exception types in C#, you can also create your own custom exceptions. Custom exceptions allow you to create exceptions that are specific to your application and provide a more fine-grained approach to exception handling. Custom exceptions can be created by defining a new class that inherits from System.Exception.
Exception Handlers: Exception handlers are blocks of code that are executed when an exception is thrown. Exception handlers can be defined in a try-catch-finally block or in a catch block. The catch block contains the exception handler, which is executed when an exception is caught. In the catch block, you can provide recovery logic, such as rolling back a transaction or closing a file, and then re-throw the exception or raise a new exception.
The try Block: The try block contains the code that might throw an exception. Transfer control to the catch block if an exception is thrown in the try block. The try block should contain only the code that is related to the exception and should not contain code that might cause side effects, such as changing the global state or modifying data.
The catch Block: The catch block contains the exception handler, which is executed when an exception is caught. In the catch block, you can provide recovery logic, such as rolling back a transaction or closing a file, and then re-throw the exception or raise a new exception. The catch block should contain only the code that is related to the exception and should not contain code that might cause side effects, such as changing global state or modifying data.
The finally Block: The finally block is optional and is executed after the try block and any catch blocks have been completed. The finally block releases resources, such as files or database connections, which need cleaning up, regardless of whether an exception is thrown or not.
Debugging Exceptions: Debugging exceptions can be a challenging task, particularly in large-scale applications. To make debugging easier, you can use tools such as the Visual Studio debugger, the System.Diagnostics namespace, and log files to troubleshoot and debug exceptions. You can also use System.Diagnostics to add trace information to your application, which can be used to track the flow of execution and identify the cause of exceptions.
Exception Safety: Exception safety is a property of software that ensures that the software behaves correctly and in a predictable manner even in the presence of exceptions. Exception safety is important for ensuring that your application is reliable, robust, and secure. To achieve exception safety, you should follow best practices for exception handling, such as using the try-catch-finally blocks correctly, choosing the right exception type to throw, and handling exceptions in a consistent and predictable manner throughout your application. Additionally, you should implement proper error handling and recovery logic in your exception handlers, and consider using transactions or other techniques to ensure that your application remains in a consistent state even in the presence of exceptions.

In conclusion, exception handling is a crucial aspect of software development, particularly in large-scale applications. By handling exceptions in a consistent and predictable manner, you can improve the reliability and stability of your application, reduce the risk of bugs, and provide a more seamless user experience for the end-user. By following best practices for exception handling in C#, you can ensure that your application is able to handle exceptions and recover gracefully from unexpected events.

“Exception handling in C#” is a crucial aspect of software development and provides a mechanism for handling and managing runtime errors and exceptions. With its many benefits, including improved user experience, debugging and troubleshooting, improved code quality, and enhanced security, exception handling is an essential part of any C# development project.

Exception Handling in C#