Chenh

ASP.net Middleware#

Official documentation: ASP.NET Core Middleware | Microsoft Learn

Middleware is a series of methods that handle HTTP requests. The above diagram demonstrates the entire process of an HTTP request flowing through middleware.

Middleware is invoked using a "pipeline" (or what I prefer to call a round-trip queue). When a WebApp has three middleware components (A, B, and C), upon receiving a request, they will be executed in the order of ABC for pre-processing, and then in the reverse order of CBA for post-processing.

public class MyMiddleware
{
    private readonly RequestDelegate _next;
    public MyMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    public async Task Invoke(HttpContext context)
    {
        // Pre-processing logic
        await _next(context);
        // Post-processing logic
    }
}

The Invoke method plays a crucial role in middleware. It is responsible for passing the request flow to the next middleware or terminal handler, and automatically executes the post-processing logic upon return.

By using the Invoke method, the pre-processing and post-processing logic of middleware can be organized together, making the code structure more concise and clear. Moreover, the use of _next(context) call to trigger the pre-processing of the next middleware achieves the chaining of middleware.

The advantage of this design is that it provides a recursive-like way to handle requests. Each middleware only needs to focus on its own pre-processing logic and passes the request to the next middleware by calling _next(context). The post-processing logic is automatically executed upon the return of the request, without the need for explicit calls.

The benefit of this pattern is that it simplifies the writing and composition of middleware, making the code more readable and maintainable. At the same time, it provides a flexible way to insert, remove, or reorder middleware to meet different requirements.

In summary, the clever design of the Invoke method allows the pre-processing and post-processing logic of middleware to be expressed in a unified and concise manner, making the use and composition of middleware more convenient and elegant.

Using Middleware#

Similar to adding dependency services, there are two ways to configure middleware: extension methods and UseMiddleware<T>().

It is important to note that, as shown in the flowchart at the beginning, the "result" of the previous middleware is the "parameter" of the next middleware, so the order of middleware is crucial.

Tip: Pay attention to the position of custom middleware, although these middleware are not mandatory.

The way middleware is invoked is somewhat similar to the TCP/IP protocol stack, isn't it?

END.

The following content is from AI

In ASP.NET, middleware is a mechanism for handling HTTP requests and responses. It allows you to perform a series of logical processing before the request reaches the target handler or before the response is returned to the client. Middleware can be used for handling routing, authentication, logging, exception handling, and various other functionalities.

Similar middleware concepts may also be adopted in other backend frameworks and languages, although the specific implementation and naming may vary. Here are some similar concepts in other backend frameworks:

• Express.js (Node.js): Express.js is a popular Node.js backend framework that uses middleware to handle requests and responses. You can register middleware functions by calling app.use() or app.useMiddleware(), and these functions will be executed in the order they are registered.
• Django (Python): Django is a Python web framework that uses middleware to handle requests and responses. You can write custom middleware classes and add them to the MIDDLEWARE setting to execute specific logic during the request handling process.
• Ruby on Rails (Ruby): Ruby on Rails is a Ruby web framework that uses middleware to handle requests and responses. You can write Rack middleware to handle requests and add them to the middleware stack of the application.

The middleware concepts in these frameworks aim to provide a flexible and extensible way to handle requests and responses. Although the specific implementation and usage may vary, their goal is to provide composable and reusable logic processing during the request handling process.

Translation: