Middleware vs. Filters in .NET Web API: Understanding the Differences with Examples

In .NET Core 6 Web API, middleware and filters are critical components for handling cross-cutting concerns, such as logging, authentication, and exception handling. Although they serve similar purposes, they operate in different ways and at different points in the request pipeline. Let’s delve into these distinctions, backed by examples, to understand when and why to use each in your .NET Core applications.

What is Middleware in .NET Core?

Middleware is software that processes requests and responses throughout the entire ASP.NET Core pipeline. Every incoming request passes through a series of middleware components configured in the Startup class, each performing specific actions. Middleware can modify the request before it reaches the controller and can manipulate the response as it leaves the controller.

Example of Middleware Usage in .NET Core

Imagine we need middleware to log every incoming HTTP request. Here’s how you can implement it:

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;

    public RequestLoggingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        Console.WriteLine($"Request Path: {context.Request.Path}");
        await _next(context); // Call the next middleware in the pipeline
    }
}

// In the Program.cs file
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseMiddleware<RequestLoggingMiddleware>();
app.MapControllers();

app.Run();        

In this example, every incoming request logs its path. The InvokeAsync method processes each request, then calls _next(context), which passes control to the next middleware in the pipeline.

Characteristics of Middleware

• Global Scope: Middleware affects every request and response in the application.
• Pipeline Control: Middleware is sequential and set up in the order defined in Startup. Order matters; middleware earlier in the pipeline can impact those later on.
• Reusability: Middleware is highly reusable and configurable across applications.

What is a Filter in .NET Core?

Filters are attributes or classes that apply to specific actions or controllers in ASP.NET Core MVC. They’re designed for handling cross-cutting concerns at a more granular level than middleware. Filters execute within the MVC pipeline, allowing you to control the behavior before or after an action executes, before or after a result is returned, or even around exception handling.

Example of Filter Usage in .NET Core

Suppose we need an action filter that logs only actions marked with this filter attribute. Here’s how you can create one:

public class LogActionFilter : IActionFilter
{
    public void OnActionExecuting(ActionExecutingContext context)
    {
        Console.WriteLine($"Action Executing: {context.ActionDescriptor.DisplayName}");
    }

    public void OnActionExecuted(ActionExecutedContext context)
    {
        Console.WriteLine($"Action Executed: {context.ActionDescriptor.DisplayName}");
    }
}

// Applying the filter to a controller or action
[LogActionFilter]
public class SampleController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        return Ok("This is an example response.");
    }
}        

In this example, the LogActionFilter logs the execution of specific actions or controllers decorated with [LogActionFilter]. It’s activated for specific actions or controllers, providing targeted control over logging behavior.

Characteristics of Filters

• Targeted Application: Filters can be applied globally, to specific controllers, or individual actions, offering fine-grained control.
• Lifecycle Hooks: Filters come with specific hooks (OnActionExecuting, OnActionExecuted, etc.), allowing precise control over action execution.
• Scoped Execution: Unlike middleware, filters run only within the MVC pipeline, meaning they won’t affect requests handled by other middleware or pipeline components outside MVC.

Middleware vs. Filters: Key Differences

When to Use Middleware vs. Filters

• Use Middleware when the functionality needs to affect all requests in the application, regardless of whether they are routed through MVC or not. Examples include logging, CORS configuration, and global error handling.
• Use Filters when you need behavior specific to the MVC pipeline, such as custom validation or logging of certain controllers or actions. Filters offer more control over specific endpoints, making them ideal for action-specific logic.

Combining Middleware and Filters

Often, real-world applications require a mix of middleware and filters. For instance, you might use middleware to log all requests and a filter to log only specific actions:

1. RequestLoggingMiddleware logs all incoming requests.
2. LogActionFilter logs specific actions or controllers, providing targeted logging in addition to the global logging done by middleware.

Conclusion

Middleware and filters each offer powerful mechanisms for handling cross-cutting concerns in .NET Core 6 Web API. Middleware provides application-wide control, ideal for generic tasks across all requests, while filters are perfect for targeted control within the MVC pipeline. By understanding the strengths of each, you can build robust, scalable web APIs that precisely manage requests and responses.