Create custom middleware in ASP.NET Core, which can be implemented by writing classes and registering. 1. Create a class containing the InvokeAsync method, handle HttpContext and RequestDelegate next; 2. Register with UseMiddleware in Program.cs. Middleware is suitable for general operations such as logging, performance monitoring, exception handling, etc. Unlike MVC filters, it acts on the entire application and does not rely on the controller. Rational use of middleware can improve structural flexibility, but should avoid affecting performance.

Creating custom middleware in ASP.NET Core is a flexible way to extend the request processing process. It allows you to insert custom logic, such as logging, pre-authentication checking, performance monitoring, etc. before HTTP requests enter the controller or before the response returns to the client.

What is middleware?

Middleware is a link in the ASP.NET Core pipeline that handles each request and response. You can understand it as a "filter" where multiple middlewares are connected in sequence to form a pipeline. Each middleware can choose whether to pass the request to the next node, or directly terminate the process and return the response.

Common built-in middlewares include UseRouting() , UseAuthentication() , and UseAuthorization() . What we need is: how to write your own middleware .

How to write custom middleware

There are usually two ways to create custom middleware:

• Delegating Middleware
• Implementing the middleware class (Class-based Middleware)

It is recommended to use classes, which has a clearer structure and is also convenient for testing and maintenance.

The steps are as follows:

1. Create a class that contains an Invoke or InvokeAsync method.
2. The method accepts HttpContext and a RequestDelegate next parameter.
3. Register the middleware in Startup.cs or Program.cs .

The sample code is as follows:

 public class MyCustomMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        // Add your logic here, for example:
        Console.WriteLine("Before request handled");

        // Continue to execute subsequent middleware await _next(context);

        Console.WriteLine("After response sent");
    }
}

Then add in Program.cs :

 app.UseMiddleware<MyCustomMiddleware>();

Note that the registration order of middleware will affect the execution order, so it should be placed in the right place.

Common application scenarios

Middleware is very suitable for some common cross-request operations, and the following are some typical scenarios:

• Logging : Records the path, time, IP address and other information of each request.
• Performance monitoring : counts the processing time of each request and is used to analyze system bottlenecks.
• Global exception handling : Catch unhandled exceptions and return error messages uniformly.
• Request Intercept : Reject requests based on specific conditions (such as blacklist IP).
• Set custom response headers : for example, add X-Powered-By or other identifiers.

For example, if you want to record the time spent on each request, you can do it like this:

 public async Task InvokeAsync(HttpContext context)
{
    var stopwatch = new Stopwatch();
    stopwatch.Start();

    await _next(context);

    stopwatch.Stop();
    Console.WriteLine($"Request {context.Request.Path} took {stopwatch.ElapsedMilliseconds} ms");
}

This approach is helpful for debugging and performance optimization.

The difference between middleware and filter

Sometimes middleware and MVC filters are confused. They all do similar things, but have different scopes of application:

• Middleware acts on the entire application, works on all requests, and does not rely on the MVC framework.
• The filter is only effective for the MVC controller and is suitable for some Action-level operations, such as parameter verification and result formatting.

If you want to process non-controller requests (such as static files) as well, you must use middleware.

In addition, the middleware can control the direction of the entire request pipeline and can even end the response before the controller executes.

Basically that's it. Writing a middleware is not complicated, but be careful not to overuse it to avoid affecting performance. Rational use of middleware can make your application structure clearer and more flexible.

The above is the detailed content of Creating Custom Middleware in ASP.NET Core C#. For more information, please follow other related articles on the PHP Chinese website!