Src Pro

21. Filters

7 min read

Filters in ASP.NET Core MVC

Filters are powerful components in ASP.NET Core MVC that allow you to intercept and execute code before, after, or even around the execution of your controller actions or Razor Pages. They provide a clean and modular way to implement cross-cutting concerns like:

  • Authentication: Verifying user identities before granting access to certain actions.
  • Authorization: Checking if a user is authorized to perform a specific action.
  • Caching: Caching responses to improve performance.
  • Error Handling: Handling exceptions and generating appropriate error responses.
  • Logging: Recording information about requests and responses.
  • Action Filtering: Modifying action parameters or results.

Purpose of Filters

  • Encapsulation: Filters encapsulate reusable logic that can be applied to multiple actions or controllers, reducing code duplication.
  • Clean Separation: They help keep your controller actions focused on their core responsibility.
  • Extensibility: ASP.NET Core MVC provides a framework for creating custom filters.

Best Practices

  • Choose the Right Filter Type: Select the appropriate filter type based on the desired interception point.
  • Dependency Injection (DI): Leverage DI to inject services into your filters.
  • Keep Filters Small and Focused: Each filter should have a single, well-defined responsibility.
  • Consider Performance: Be mindful of the potential performance impact of filters.
  • Order Matters: Understand the default order and how to customize it.

Action Filters

Action filters, implemented using the IActionFilter interface, are invoked before and after an action method executes.

  • Pre-Action Logic (OnActionExecuting):
    • Inspect and modify the action arguments or the ActionExecutingContext object.
    • Short-circuit the action execution (e.g., by setting the Result property of the context).
  • Post-Action Logic (OnActionExecuted):
    • Inspect and modify the action result or the ActionExecutedContext object.
    • Log information about the action’s execution.

Code Explanation

// PersonsListActionFilter.cs (Action Filter)
 
public class PersonsListActionFilter : IActionFilter
{
    private readonly ILogger<PersonsListActionFilter> _logger; // Injected logger
 
    public PersonsListActionFilter(ILogger<PersonsListActionFilter> logger)
    {
        _logger = logger;
    }
 
    public void OnActionExecuted(ActionExecutedContext context)
    {
        _logger.LogInformation("PersonsListActionFilter.OnActionExecuted method");
    }
 
    public void OnActionExecuting(ActionExecutingContext context)
    {
        _logger.LogInformation("PersonsListActionFilter.OnActionExecuting method");
    }
}

Applying the Filter

You can apply this filter in several ways:

  • Globally: Register the filter in Program.cs.
  • Controller-Level: Apply the [PersonsListActionFilter] attribute to your controller class.
  • Action-Level: Apply the [PersonsListActionFilter] attribute to specific action methods.
// PersonsController.cs
 
[Route("[controller]")]
[PersonsListActionFilter] // Apply the filter to the entire controller
public class PersonsController : Controller
{
    // ... your actions ...
}

Filter Arguments

Filters often require additional data or configuration to perform their tasks effectively.

[TypeFilter(typeof(ResponseHeaderActionFilter), Arguments = new object[] { "My-Key-From-Action", "My-Value-From-Action", 1 })]

Global Filters

Global filters are applied to all controllers and actions in your application.

// Program.cs
 
builder.Services.AddControllersWithViews(options => {
    // Registering a global filter
    options.Filters.Add(new ResponseHeaderActionFilter(logger, "My-Key-From-Global", "My-Value-From-Global", 2));
});

Custom Order of Filters

By default, ASP.NET Core executes filters in a predefined order. You can customize this order:

  • Order Property: Both [TypeFilter] and [ServiceFilter] have an Order property.
  • IOrderedFilter Interface: Implement this interface for more fine-grained control.
public class ResponseHeaderActionFilter : IActionFilter, IOrderedFilter
{
    public int Order { get; }
 
    public ResponseHeaderActionFilter(ILogger<ResponseHeaderActionFilter> logger, string key, string value, int order)
    {
        Order = order; // Set the order of the filter
    }
    // ...
}

Filter Execution Order Example

[TypeFilter(typeof(ResponseHeaderActionFilter), Arguments = new object[] { "My-Key-From-Controller", "My-Value-From-Controller", 3 }, Order = 3)]
public class PersonsController : Controller
{
    [Route("[action]")]
    [Route("/")]
    [TypeFilter(typeof(PersonsListActionFilter), Order = 4)]
    [TypeFilter(typeof(ResponseHeaderActionFilter), Arguments = new object[] { "MyKey-FromAction", "MyValue-From-Action", 1 }, Order = 1)]
    public async Task<IActionResult> Index(string searchBy, string? searchString, string sortBy = nameof(PersonResponse.PersonName), SortOrderOptions sortOrder = SortOrderOptions.ASC)
    {
        // ...
    }
}

Execution Order for the Index action:

  1. ResponseHeaderActionFilter (from action, Order = 1)
  2. ResponseHeaderActionFilter (from controller, Order = 3)
  3. PersonsListActionFilter (Order = 4)

Asynchronous Filters

ASP.NET Core MVC filters support asynchronous execution through the IAsyncActionFilter and IAsyncResultFilter interfaces.

IAsyncActionFilter

public interface IAsyncActionFilter
{
    Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next);
}

IAsyncResultFilter

public interface IAsyncResultFilter
{
    Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next);
}

Short-Circuiting Action Filters

Short-circuiting is a technique where an action filter can decide to terminate the filter pipeline early and directly return a result without invoking the action method.

// PersonCreateAndEditPostActionFilter.cs (Async Action Filter)
 
public class PersonCreateAndEditPostActionFilter : IAsyncActionFilter
{
    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        if (context.Controller is PersonsController personsController)
        {
            if (!personsController.ModelState.IsValid)
            {
                var personRequest = context.ActionArguments["personRequest"];
                context.Result = personsController.View(personRequest); // Short-circuit
            }
            else
            {
                await next(); // Continue the pipeline if model is valid
            }
        }
        else
        {
            await next();
        }
    }
}

Result Filters

Result filters, implemented by IResultFilter or IAsyncResultFilter, are triggered just before and after the execution of an action result.

  • IResultFilter: Methods: OnResultExecuting(ResultExecutingContext context), OnResultExecuted(ResultExecutedContext context)
  • IAsyncResultFilter: Methods: OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)

Resource Filters

Resource filters, implementing IResourceFilter or IAsyncResourceFilter, are executed before and after model binding and action execution.

  • Common Use Cases: Caching, performance monitoring, resource cleanup.

Authorization Filters

Authorization filters, implementing IAuthorizationFilter, are responsible for determining whether a user is allowed to access a particular action method.

public void OnAuthorization(AuthorizationFilterContext context)
{
    // Check authentication and authorization policies
    // If authorization fails, set context.Result to an appropriate result
}

Exception Filters

Exception filters, implemented through IExceptionFilter, handle exceptions thrown during the execution of action methods or other filters.

public void OnException(ExceptionContext context)
{
    // Log exceptions, create custom error responses
    context.ExceptionHandled = true;
    context.Result = new StatusCodeResult(500);
}

IAlwaysRunResultFilter

The IAlwaysRunResultFilter interface guarantees that its methods execute even if another filter short-circuits the result pipeline.

public class PersonAlwaysRunResultFilter : IAlwaysRunResultFilter
{
    public void OnResultExecuted(ResultExecutedContext context)
    {
        // Logic to execute after the result has been executed
    }
 
    public void OnResultExecuting(ResultExecutingContext context)
    {
        // Logic to execute before the result is executed
    }
}

Filter Overrides

Filter overrides empower you to selectively disable or alter the behavior of filters on a per-action or per-controller basis.

SkipFilter Attribute

// SkipFilter.cs
public class SkipFilter : Attribute, IFilterMetadata
{
}
// PersonAlwaysRunResultFilter.cs
public void OnResultExecuting(ResultExecutingContext context)
{
    if (context.Filters.OfType<SkipFilter>().Any())
    {
        return; // Skip this filter if the SkipFilter attribute is present
    }
    // ... Your filter logic here ...
}
// In your controller
[SkipFilter] // Skip specific filters for this action
public IActionResult SomeAction()
{
    // ...
}

Service Filters

Service filters, applied using the [ServiceFilter] attribute, inject dependencies directly into your filters from the DI container.

[ServiceFilter(typeof(PersonsListActionFilter), Order = 4)]

IFilterFactory Interface

The IFilterFactory interface allows you to create filter instances dynamically at runtime.

public class ResponseHeaderFilterFactoryAttribute : Attribute, IFilterFactory
{
    public bool IsReusable => false;
 
    public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
    {
        var filter = serviceProvider.GetRequiredService<ResponseHeaderActionFilter>();
        filter.Key = _key;
        filter.Value = _value;
        filter.Order = _order;
        return filter;
    }
}

Key Points to Remember

Filter Types

  • IActionFilter: Before and after action execution.
  • IAuthorizationFilter: Authorization checks before action execution.
  • IResourceFilter: Before and after model binding and action execution.
  • IExceptionFilter: Handles exceptions.
  • IResultFilter: Before and after action result execution.
  • IAlwaysRunResultFilter: Guaranteed execution, even if other filters short-circuit.

Key Filter Interfaces and Attributes

  • [TypeFilter]: Apply a filter by its type, with optional arguments.
  • [ServiceFilter]: Resolve a filter from the DI container.
  • IFilterFactory: Create filter instances dynamically.
  • IOrderedFilter: Control filter ordering.

Short-Circuiting

  • Action Filters: Set context.Result to bypass the action.
  • Result Filters: Set context.Cancel = true and provide a new context.Result.
  • Resource Filters: Set context.Result to bypass action execution.
  • Authorization Filters: Set context.Result to bypass the entire pipeline.

Filter Overrides

  • [NonAction]: Exclude a method from being treated as an action.
  • Custom attributes like [SkipFilter] for finer control.

Best Practices

  • Choose the right filter type for your needs.
  • Use DI to inject services into your filters.
  • Keep filters small and focused.
  • Be mindful of performance impact.
  • Understand and customize filter order.

Interview Tips

  • Explain filter types and their use cases.
  • Demonstrate short-circuiting effectively.
  • Discuss custom filter scenarios.
  • Explain filter ordering.
  • Showcase best practices.

Graph View