Exception Handling in C# Applications

In C#, an exception is a runtime error or unexpected behavior that occurs during the execution of a program. Exceptions can be caused by various factors, such as invalid input, file not found, division by zero, or other unhandled conditions in the code. When an exception occurs, the normal flow of the program is disrupted and the runtime system looks for a suitable exception handler to handle the exceptional situation.

Exception & Errors Handling

No mater how good our program is, it always have to be able to handle possible errors. Most applications today contain some form of error handling. Unfortunately, the level and quality of error handling varies greatly. Some applications provide so much error handling that the application constantly raises alarms, even if the user provides the correct input. Other applications provide error handling that only a developer could love. The messages are replete with jargon and the data is useful only if you designed the application. Still other applications provide one-size-fits-all error handling that simply tells the user an error occurred without saying what error it was or how to fix it.

Exceptions handling in C#

Exception handling in C# is done using the try, catch, and finally blocks. C# creates an object (or throw) when a particular error condition occurs. This object has data members that store information about the nature of the error. Although .NET provides with many predefined exception classes yet we can create our own exception classes.

The generic exception class in C# .NET is System.Exception which is derived from System.Object. There are two important classes derived from System.Exception e.g. System.SystemException and System.ApplicationException. Here’s a basic structure of exception handling in C#:

Example of Exceptions handling in C#

try
{
    // Code that may cause an exception
}
catch (ExceptionType1 ex1)
{
    // Handle exception of type ExceptionType1
}
catch (ExceptionType2 ex2)
{
    // Handle exception of type ExceptionType2
}
// Add more catch blocks for different exception types as needed
catch (Exception ex)
{
    // Handle any other exceptions
}
finally
{
    // Code that will always be executed, whether an exception occurs or not
}

The execution flow enters into a try block. If the error occurs the control automatically goes to the catch block and then the finally block is executed. Here is a breakdown of the components used in the C# example above:

• try: This block contains the code that might raise an exception. If an exception occurs within the try block, the control is transferred to the appropriate catch block.
• catch: Each catch block specifies a type of exception that it can handle. If the type of the thrown exception matches the type specified in a catch block, that block is executed. You can have multiple catch blocks to handle different types of exceptions.
• finally: This block contains code that will be executed whether an exception occurs or not. It is optional, and you can omit it if you don’t need it. The finally block is often used for cleanup tasks, such as closing files or releasing resources.

We can also catch multiple errors from our one try block. For example an overflow and an array index out of bounds. We assume that our code have two boolean variables, OverFlow, OutOfBounds, which indicates that exception is occurred. So our example would look like

try
{
 //code for the program

 if (OverFlow == true)
  throw new OverflowException();

 //more code for the program
 if(OutOfBounds == true)
  throw new IndexOutOfRangeException();

 //If no error then continue the normal execution
}
catch(OverflowException ex)
{
 //error handling code
}
catch(IndexOutOfRangeException ex)
{
 //eror handling code
}
finally
{
 //clean up the resources
}

Using the Finally Keyword

The finally keyword is an addition to the try/catch statement. You can use it in addition to, or in place of, the catch keyword. Any code that appears as part of the finally portion of the statement will run even after an error occurs. This keyword comes in handy when you want to attempt to reduce the damage of an error. For example, you might need to close a file to ensure a graceful failure of your application. Here are a couple of  examples of the finally keyword in use.

try
{
    int numerator = 10;
    int denominator = 0;
    int result = numerator / denominator; // This will throw a System.DivideByZeroException
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Error: Attempted to divide by zero");
}
catch (Exception ex)
{
    Console.WriteLine($"An unexpected error occurred: {ex.Message}");
}
finally
{
    // Cleanup code, if needed
}

Here is another C# example to show the usage of try/catch and finally blocks.

private void btnThrow3_Click(object sender, System.EventArgs e) {
  try {
    // The call will fail because we've thrown an exception.
    MyBadCall1(12);
  } catch {
    // Display an error message.
    MessageBox.Show("Invalid Exception Error",
      "Application Error",
      MessageBoxButtons.OK,
      MessageBoxIcon.Error);
    // Try to return.
    return;
  } finally {
    // The example must run this code.
    MessageBox.Show("Must Run This Code",
      "Finally Code",
      MessageBoxButtons.OK,
      MessageBoxIcon.Information);
  }
  // The example will try to run this code, but won't
  // because of the exception.
  MessageBox.Show("This Code Won't Run",
    "Code Outside Try//Catch",
    MessageBoxButtons.OK,
    MessageBoxIcon.Information);
}

As you can see, we’re using MyBadCall1() again to generate an error. In this case, the catch portion of the try/catch statement will generate a simple usage telling you of the error. The message in the finally portion of the try/catch statement will also appear, despite the return statement in the catch portion. The finally code will always run. However, because of the return statement, the message box outside the try/catch statement will never appear.

Why Exception Handling is important?

Handling exceptions in C# programs and applications is crucial for several reasons:

1. Graceful Error Recovery: Exception handling allows you to gracefully recover from errors and prevent the entire application from crashing. By catching and handling exceptions, you can guide the program to take appropriate actions, display meaningful error messages, and possibly continue its execution.
2. Improved User Experience: Handling exceptions helps in providing a better user experience by presenting users with understandable error messages rather than technical stack traces. Users are more likely to trust and continue using software that handles errors gracefully and communicates issues in a user-friendly manner.
3. Debugging and Troubleshooting: Exception handling aids in the debugging process. When exceptions are caught and logged, developers can review error details, identify the root cause of the problem, and fix issues more efficiently. Logging exceptions is particularly helpful for diagnosing problems that occur in production environments.
4. Enhanced Robustness: Proper exception handling contributes to the overall robustness and reliability of an application. It allows developers to anticipate potential issues and implement measures to handle them, making the application more resilient to unexpected situations.
5. Resource Cleanup: The finally block in exception handling provides a mechanism to ensure that critical resources (such as files, network connections, or database connections) are properly released, regardless of whether an exception occurs.
6. Security Considerations: Exception handling can play a role in security by preventing sensitive information from being exposed to users. By catching and handling exceptions, developers can control the information disclosed in error messages.
7. Code Readability: Code that includes proper exception handling is often more readable and maintainable. It explicitly defines how the program should respond to exceptional conditions, making the codebase more understandable for developers.
8. Early Detection of Issues: Exception handling helps in the early detection of issues during the development phase. It allows developers to identify and address potential problems before the application is deployed.
9. Compliance with Best Practices: Following exception handling best practices is considered a standard in software development. It demonstrates a commitment to writing robust and reliable code, contributing to the overall quality of the software.
10. Maintaining Program Flow: Exception handling allows developers to manage the flow of their programs effectively, especially when dealing with potentially error-prone operations. Without proper exception handling, unexpected errors could disrupt the normal flow of execution, leading to unpredictable behavior or abrupt program termination.

In essence, exception handling provides a structured way to address and navigate through exceptional conditions, ensuring that the program’s flow remains controlled and predictable even in the face of unexpected errors. This contributes to the overall stability and reliability of the software.