Difference between ExceptionLogger vs. ExceptionFilter vs. ExceptionHandler in .NET Core

No Comment

We will understand the difference between ExceptionLogger, ExceptionFilter, and ExceptionHandler which helps to handle exceptions in several ways in .NET Core. In this article, we will explore each of these techniques, discussing when and how to use them with real-world examples.

Difference – Overview

Exception loggers	Exception filters	Exception handlers
Exception loggers are the solution to seeing all unhandled exception caught by Web API.	Exception filters are the easiest solution for processing the subset unhandled exceptions related to a specific action or controller.	Exception handlers are the solution for customizing all possible responses to unhandled exceptions caught by Web API.

ExceptionLogger

ExceptionLogger allows you to log exceptions that occur during the execution of your application. It provides a way to capture detailed information about exceptions, such as the exception message, stack trace, and other relevant data, and then log this information using a custom logging mechanism.

ExceptionLogger is typically used for auditing and monitoring purposes. It helps developers and administrators track the occurrence of exceptions in an application, enabling them to diagnose issues, identify error patterns, and take corrective actions.

When to use ExceptionLogger:

You might use an ExceptionLogger to log exceptions to a central log database or send alerts to a monitoring system like Application Insights or ELK Stack.
Use ExceptionLogger when you want to log exceptions that occur during the execution of your application. ExceptionLogger allows you to capture detailed information about exceptions, including the exception message, stack trace, and other relevant data.

Purpose: all unhandled exceptions (before they even reach exception filters)
Scope: global

public class CustomExceptionLogger : ExceptionLogger
{
    public override void Log(ExceptionLoggerContext context)
    {
        // Log the exception details using your preferred logging mechanism
        LogHelper.LogException(context.Exception);
    }
}

In this example, we create a custom ExceptionLogger that logs exceptions using a custom logging utility. You can then register this logger in your application’s configuration to handle exception logging.

ExceptionFilter

ExceptionFilter allows you to perform custom actions in response to specific exceptions during the execution of your application. It lets you modify the HTTP response, redirect the user, or execute any other logic based on the exception type or conditions you define.

ExceptionFilters are useful when you need to handle exceptions in a more fine-grained manner. You can use them to implement custom error handling behavior for specific scenarios. For example, you might want to return a user-friendly error message for a particular exception type or redirect the user to a login page if their session has expired.

When to use ExceptionFilter:

You can create an ExceptionFilter to catch and handle authorization-related exceptions by redirecting the user to a login page or returning a 403 Forbidden status code.
ExceptionFilters are useful when you need to perform custom actions in response to specific exceptions. They allow you to modify the HTTP response, redirect the user, or perform any other action based on the exception type or condition.

Purpose: handle (not log) exceptions
Scope: per action, per controller, global

public class CustomExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        if (context.Exception is CustomNotFoundException)
        {
            // Handle the not found exception by returning a custom response
            context.Result = new NotFoundObjectResult("Resource not found");
            context.ExceptionHandled = true;
        }
    }
}

In this example, a CustomExceptionFilter is used to catch a specific CustomNotFoundException and return a custom response. You can register this filter globally or on specific controllers or action methods as needed.

ExceptionHandler

ExceptionHandler deals with unhandled exceptions that occur during the execution of your application. It provides a way to customize the behavior when an unhandled exception is encountered, such as redirecting the user to an error page, returning a specific response, or performing cleanup tasks.

ExceptionHandler is designed to handle exceptions that propagate beyond the scope of regular exception handling mechanisms like try-catch blocks. It ensures that your application gracefully manages unhandled exceptions, preventing crashes and providing a more user-friendly experience.

When to use ExceptionHandler:

You can configure an ExceptionHandler to catch unhandled exceptions and return a custom error response with a 500 Internal Server Error status code. This helps ensure that users receive a meaningful error message rather than seeing a generic server error page.
ExceptionHandler is suitable for handling unhandled exceptions that occur during the execution of your application. It allows you to customize the behavior when an unhandled exception occurs, such as redirecting the user to an error page or returning a specific response.

Purpose: log and handle unpredictable/unexpected exceptions
Scope: global

public class CustomExceptionHandler : IExceptionHandler
{
    public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
    {
        // Handle the exception and return a custom response
        context.Result = new ObjectResult("An error occurred")
        {
            StatusCode = StatusCodes.Status500InternalServerError
        };
        return Task.CompletedTask;
    }
}

In this example, a CustomExceptionHandler is used to catch unhandled exceptions and return a custom response with a 500 Internal Server Error status code. You can configure the ExceptionHandler in your application’s startup code to define how unhandled exceptions should be handled.

Conclusion
Exception handling is a crucial part of any application’s development, and in .NET Core, you have several options to tailor your approach to your specific needs. ExceptionLogger, ExceptionFilter, and ExceptionHandler each serve distinct purposes, allowing you to log, filter, and handle exceptions effectively.

reference: web-api-global-error-handling