Commonly Used Types of Exceptions in .NET, C#, ASP.NET, .NET Core, and API

0 0

Exceptions are critical in C# and .NET for handling errors and ensuring robust application performance. When an error occurs, exceptions provide detailed information that helps identify the issue and manage it gracefully.

Commonly Used Exceptions in .NET:

• System.Exception: The base class for all exceptions in C#. Any custom exception must inherit from this.
• ArgumentNullException: Thrown when a null reference is passed to a method that does not accept it.
• ArgumentOutOfRangeException: Thrown when the value passed to a method is outside the valid range.
• NullReferenceException: Thrown when trying to use an object reference that is null.
• IndexOutOfRangeException: Thrown when an attempt is made to access an index in an array or collection that is out of bounds.
• DivideByZeroException: Thrown when there’s an attempt to divide by zero.
• FileNotFoundException: Thrown when a file is not found.
• InvalidOperationException: Thrown when a method call is invalid for the current state of the object.
• NotImplementedException: Thrown when a requested method or operation is not implemented.
• FormatException: Thrown when a format is invalid, like trying to parse a string as an integer.
• HttpRequestException: Common in APIs, thrown when there is an issue with an HTTP request.
• TaskCanceledException: Thrown when an asynchronous operation is canceled.
• UnauthorizedAccessException: Thrown when access to a resource is denied.
• TimeoutException: Thrown when an operation exceeds its allotted time to complete.

Real-World Analogy for Exceptions

Think of exceptions as traffic lights on a road:

• Green light: Everything is normal, traffic flows (program runs smoothly).
• Yellow light: Caution! There might be a potential problem ahead (an issue is detected, but the program can handle it).
• Red light: Stop! Something is wrong (an exception occurs, halting the program until it’s resolved).

Exceptions act like the red light, stopping the execution until the issue is addressed. Using try-catch blocks ensures the program handles these “traffic light” errors effectively.

Tricky and Important Q&A

Q1: What is the difference between NullReferenceException and ArgumentNullException?

Answer:

• NullReferenceException occurs when trying to access members of an object that is null.
• ArgumentNullException occurs when a method receives null as an argument where null is not valid.

Q2: Can you throw an exception inside a finally block?

Answer: Yes, but it’s discouraged. If an exception is thrown inside a finally block, it may override any exception thrown in the try or catch block, making debugging difficult.

Q3: What’s the best way to handle exceptions in an API?

Answer: In an API, use global exception handling middleware to catch all unhandled exceptions and return proper HTTP status codes, such as 500 Internal Server Error, with detailed error messages.

Q4: Why is catching generic exceptions (catch(Exception ex)) discouraged?

Answer: Catching generic exceptions can hide bugs or unintended exceptions, making it harder to identify the root cause. It’s better to catch specific exceptions.

Example of Handling Exceptions in .NET

public class Program {
    public static void Main() {
        try {
            int[] numbers = { 1, 2, 3 };
            Console.WriteLine(numbers[5]);  // This will throw an IndexOutOfRangeException
        }
        catch (IndexOutOfRangeException ex) {
            Console.WriteLine($"Index error: {ex.Message}");
        }
        catch (Exception ex) {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
        finally {
            Console.WriteLine("Cleaning up resources...");
        }
    }
}

Explanation:

• try block: Code that may throw an exception.
• catch block: Handles specific exceptions, in this case, IndexOutOfRangeException.
• finally block: Executes regardless of whether an exception occurs, typically used for cleanup.

How Exceptions Work with OOP Concepts

Exceptions are tightly integrated into object-oriented programming (OOP) principles:

• Encapsulation: By throwing exceptions when something goes wrong, classes protect their internal state from becoming invalid.
• Inheritance: Custom exceptions can inherit from the base System.Exception class, allowing developers to create specific exceptions tailored to their needs.
• Polymorphism: Multiple catch blocks can handle different types of exceptions, offering flexibility in error handling.

Example of Custom Exception Inheritance:

public class InsufficientFundsException : Exception {
    public InsufficientFundsException(string message) : base(message) { }
}

public class BankAccount {
    public decimal Balance { get; private set; }

    public void Withdraw(decimal amount) {
        if (amount > Balance) {
            throw new InsufficientFundsException("Not enough balance.");
        }
        Balance -= amount;
    }
}

public class Program {
    public static void Main() {
        BankAccount account = new BankAccount();
        try {
            account.Withdraw(500);  // Throws custom InsufficientFundsException
        }
        catch (InsufficientFundsException ex) {
            Console.WriteLine(ex.Message);
        }
    }
}

Benefits of Handling Exceptions

• Graceful Error Handling: Prevents the application from crashing abruptly and allows it to recover from certain errors.
• Detailed Error Reporting: Exceptions provide detailed error messages and stack traces that help in debugging.
• Cleaner Code: Using exceptions leads to cleaner, more maintainable code compared to relying on error codes or return values.
• Improved User Experience: By handling exceptions properly, applications can display user-friendly error messages rather than cryptic system errors.

Code Snippet Using Try-Catch for an API Example

In an ASP.NET Core API, we can use exception handling middleware to catch and process all exceptions globally:

public class Startup {
    public void Configure(IApplicationBuilder app) {
        app.UseExceptionHandler("/error");

        app.Use(async (context, next) => {
            try {
                await next();
            }
            catch (Exception ex) {
                Console.WriteLine($"Exception caught: {ex.Message}");
                context.Response.StatusCode = 500;
                await context.Response.WriteAsync("An unexpected error occurred.");
            }
        });
    }
}

Explanation:

• Global Error Handling: The API handles exceptions globally, logging the error and returning a 500 Internal Server Error response to the client.
• User-Friendly Error Messages: The response contains a simplified message for the user while the actual error is logged for developers to troubleshoot.

Conclusion

In .NET, C#, ASP.NET, and .NET Core, handling exceptions is essential for building robust, error-resistant applications. Common exceptions like NullReferenceException, IndexOutOfRangeException, and HttpRequestException allow developers to pinpoint issues and handle them gracefully. Exceptions play a vital role in implementing OOP principles like encapsulation, inheritance, and polymorphism, while global error handling in APIs ensures a smoother experience for users. Understanding and properly handling exceptions can improve code quality, maintainability, and user experience.