Handling Errors And Exception in Web API

Introduction:

In software development, errors and exceptions are both types of events that occur when a program encounters a problem or encounters an unexpected situation. However, there is a difference between errors and exceptions:

1. Error: An error is a more severe and typically unrecoverable problem that prevents the program from continuing its normal execution. When an error occurs, the program is usually terminated abruptly.
2. Exception: An exception is an event that occurs during the execution of a program that disrupts the normal flow of the program but can be handled and recovered from. Exceptions are generally caused by exceptional conditions or errors that occur within the program’s logic. Examples include dividing by zero, attempting to access a null object, or encountering invalid input.

Here is an examples for an error and exception in C#:

Example of an Error:

// Accessing an out-of-bounds index in an array
int[] numbers = { 1, 2, 3 };
int value = numbers[3]; // This will throw an error (IndexOutOfRangeException)
Console.WriteLine(value); // This line will not be executed

In this example, accessing the index 3 in the numbers array throws an IndexOutOfRangeException. This is an error because the index is out of bounds, and it causes the program to terminate abruptly. The line that attempts to print value will not be executed.

Example of an Exception:

try
{
    // Parsing an invalid string to an integer
    string invalidNumber = "ABC";
    int number = int.Parse(invalidNumber); // This will throw an exception (FormatException)
    Console.WriteLine(number); // This line will not be executed
}
catch (FormatException ex)
{
    // Exception handler for FormatException
    Console.WriteLine("Invalid number format!");
    Console.WriteLine("Exception details: " + ex.Message);
}

In this example, we attempt to parse the string "ABC" to an integer using int.Parse(). Since the string is not a valid integer representation, a FormatException is thrown. This is an exception because it is an exceptional condition that can be caught and handled. The catch block specifically handles the FormatException, displaying a custom error message and the details of the exception.

The line that attempts to print number will not be executed because the exception is thrown, and the program flow transfers to the catch block.

Here’s an example of how to handle an exception in C# using a try-catch block:

try
{
    // Code that may throw an exception
    int result = DivideNumbers(10, 0);
    Console.WriteLine("Result: " + result); // This line will not be executed
}
catch (DivideByZeroException ex)
{
    // Exception handler for DivideByZeroException
    Console.WriteLine("Cannot divide by zero!");
    Console.WriteLine("Exception details: " + ex.Message);
}
catch (Exception ex)
{
    // Generic exception handler
    Console.WriteLine("An error occurred!");
    Console.WriteLine("Exception details: " + ex.Message);
}
finally
{
    // Code that always executes, regardless of whether an exception occurred or not
    Console.WriteLine("Finally block executed.");
}

–> In this example, we have a try block where the code that may throw an exception is placed. If an exception occurs, it is caught by the appropriate catch block based on the type of exception.

–> In the first catch block, we specifically handle the DivideByZeroException by displaying a custom error message indicating that division by zero is not allowed.

–> The second catch block acts as a generic exception handler that catches any other exception types that are not explicitly handled. It displays a generic error message and the details of the exception.

–> The finally block is optional but allows you to include code that will always execute, regardless of whether an exception occurred or not. It is commonly used for cleanup operations or resource releases.

By using try-catch blocks, you can handle exceptions gracefully, display meaningful error messages, and execute necessary cleanup code.

Conclusion:

Overall, errors are severe problems that usually result in the program being terminated, while exceptions are exceptional conditions that can be caught and handled to prevent program crashes and provide more robust error handling.

Hence we have created a difference between the error and the exception in Asp.net. Other concepts of Dot net topics will be covered in the upcoming blogs…