M B A R K's Blog
Creating Custom Exception Filters in ASP.NET Core

Creating Custom Exception Filters in ASP.NET Core

M B A R K's photo
M B A R K
·

6 min read

Table of contents

ASP.NET Core provides a way to handle exceptions that occur during the execution of an application. Exception filters are one way to do this, and they allow developers to execute custom logic when an exception is thrown. In this article, we will learn how to create custom exception filters in ASP.NET Core and some examples of how to use them.

What are Exception Filters?

Exception filters are a way to handle exceptions that occur during the execution of an application. They are executed when an exception is thrown and allow developers to perform custom logic, such as logging the exception or returning a custom response to the client. Exception filters can be applied at different levels of an application, including on controllers, actions, and globally.

Creating a Custom Exception Filter

To create a custom exception filter, we need to create a class that implements the IExceptionFilter interface. This interface defines a single method, OnException, which is called when an exception is thrown.

public class MyExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        // Custom exception handling logic goes here
    }
}

Registering a Custom Exception Filter

Once we have created our custom exception filter, we need to register it with the application. This can be done in the Startup class of the application.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers(options =>
    {
        options.Filters.Add(new MyExceptionFilter());
    });
}

Using a Custom Exception Filter

Once we have registered our custom exception filter, it will be executed whenever an exception is thrown. We can use it to perform custom logic, such as logging the exception or returning a custom response to the client.

public class MyExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        // Log the exception
        Console.WriteLine(context.Exception);

        // Return a custom response to the client
        context.Result = new JsonResult("An error has occurred. Please try again later.");
    }

Apply an Exception Filter to a Specific Action or Controller

You can also apply an exception filter to a specific action or controller without registering it in the Startup class.

Using TypeFilter

One way to do this is by using the TypeFilter attribute and passing in the type of the exception filter as a parameter.

[TypeFilter(typeof(MyExceptionFilter))]
public class MyController : Controller
{
    public IActionResult MyAction()
    {
        // Action logic goes here
    }
}

In this example, the MyExceptionFilter will be applied to all actions in the MyController class.

Using ServiceFilter

Alternatively, you can also create an instance of the exception filter and apply it directly to the action using the ServiceFilter attribute

[ServiceFilter(typeof(MyExceptionFilter))]
public class MyController : Controller
{
    public IActionResult MyAction()
    {
        // Action logic goes here
    }
}

This way the filter will be executed only for the MyAction action of the MyController class.

In both cases, it's not necessary to register the exception filter in the Startup class. The TypeFilter and ServiceFilter attributes take care of creating and registering the filter for the specific controller or action.

Keep in mind that in order for these attributes to work, the filter class should have a public constructor, otherwise an exception will be thrown when the filter is created.

Inheriting from Attribute

Another way to apply an exception filter to a specific action or controller without registering it in the Startup class is by creating a custom attribute that inherits from Attribute and implements IExceptionFilter or IAsyncExceptionFilter.

Here's an example of a custom attribute that implements the IExceptionFilter interface:

public class MyExceptionFilterAttribute : Attribute, IExceptionFilter
{
    private readonly ILogger<MyExceptionFilterAttribute> _logger;

    public MyExceptionFilterAttribute(ILogger<MyExceptionFilterAttribute> logger)
    {
        _logger = logger;
    }

    public void OnException(ExceptionContext context)
    {
        _logger.LogError(context.Exception, "An error occurred");
        context.Result = new JsonResult("An error has occurred. Please try again later.");
    }
}

In this example, the MyExceptionFilterAttribute class inherits from Attribute and implements IExceptionFilter. It also has a constructor that takes in an ILogger<MyExceptionFilterAttribute> instance. The OnException method logs the exception using the provided logger and sets the Result property of the ExceptionContext to a new JsonResult containing the message "An error has occurred. Please try again later."

Then you can apply this attribute to any action or controller you want

[MyExceptionFilter]
public class MyController : Controller
{
    public IActionResult MyAction()
    {
        // Action logic goes here
    }
}

This way, MyExceptionFilterAttribute will be executed for the MyAction action of the MyController class.

By creating a custom attribute that implements the IExceptionFilter interface, we can easily apply the filter to any action or controller without having to register it in the Startup class.

You can also create an attribute that implements IAsyncExceptionFilter in case you need to filter the exception asynchronously.

Real-World Examples

SqlException Filter

Here's an example of a custom exception filter that handles SqlException and returns a custom response to the client:

public class SqlExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        if (context.Exception is SqlException)
        {
            context.Result = new JsonResult("A database error has occurred. Please try again later.");
        }
    }
}

In this example, the SqlExceptionFilter class implements the IExceptionFilter interface. The OnException method checks if the exception is a SqlException and if so, sets the Result property of the ExceptionContext to a new JsonResult containing the message "A database error has occurred. Please try again later."

Then you can apply this attribute to any action or controller that makes a call to the database.

[TypeFilter(typeof(SqlExceptionFilter))]
public class MyController : Controller
{
    public IActionResult MyAction()
    {
        // Action logic goes here
    }
}

This way, SqlExceptionFilter will be executed for the MyAction action of the MyController class.

In this example, the custom exception filter checks for SqlException and returns a custom response to the client. This is a useful approach if you want to handle specific types of exceptions in a specific way, for example, returning a custom message to the client when a database error occurs.

You can also apply the filter globally, but keep in mind that it will be executed for all actions, not only the ones that make a call to the database.

DbUpdateConcurrencyException Filter

The following is an example of a custom exception filter that handles DbUpdateConcurrencyException when using EF Core. The DbUpdateConcurrencyException is thrown by EF Core when there is a concurrency conflict when trying to update a database record.

public class DbUpdateConcurrencyExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        if (context.Exception is DbUpdateConcurrencyException)
        {
            context.Result = new JsonResult("The record you are trying to update has been modified by another user. Please refresh the page and try again.");
            context.ExceptionHandled = true;
        }
    }
}

In this example, the DbUpdateConcurrencyExceptionFilter class implements the IExceptionFilter interface. The OnException method checks if the exception is a DbUpdateConcurrencyException and if so, sets the Result property of the ExceptionContext to a new JsonResult containing the message "The record you are trying to update has been modified by another user. Please refresh the page and try again." and also sets context.ExceptionHandled = true to indicate that the exception was handled.

Then you can apply this attribute to any action or controller that makes a call to the database.

[TypeFilter(typeof(DbUpdateConcurrencyExceptionFilter))]
public class MyController : Controller
{
    public IActionResult MyAction()
    {
        // Action logic goes here
    }
}

This way, DbUpdateConcurrencyExceptionFilter will be executed for the MyAction action of the MyController class.

In this example, the custom exception filter checks for DbUpdateConcurrencyException and returns a custom response to the client. This is a useful approach if you want to handle concurrency conflicts in a specific way, for example, by asking the user to refresh the page and try again.

You can also apply the filter globally, but keep in mind that it will be executed for all actions, not only the ones that make a call to the database.

You could also add more logic to the filter to resolve the concurrency conflict, for example by getting the current values from the database and merging them with the values the user is trying to update.

asp.net coreC#