Talk about Middleware

First, let's talk about the basic concepts

In fact, about middleware , It is not something mysterious . Now that we are positioned in shallow conversation （ The main thing is that we won't ）, Just take out a few typical application scenarios to chat . Notice that this is a small scene , It's not that generalized middleware , It's just dotnetcore Middleware in the system framework .

I feel middleware , That is, those systems in the whole network request process should not be managed , Or the troublesome part of management , Carry it out alone , Leave it to the middleware for unified processing .

So let's say for example , We go to work , To earn money for work , But after finding a job , Find out what files to deal with , Social security , Provident fund and other messy things , Both trouble , And indispensable . In real life, there will be some special “ Administration hall ” To deal with these things ,

The system we developed is the same , It should be business oriented , Serving the actual business needs . And if there is too much code in the system to deal with things you don't want to do with business , It will greatly increase the complexity of the system code , The expansion of subsequent business is very troublesome . The ones mentioned above “ Irrelevant to business ” Things that are , It generally includes the following aspects ： journal , to grant authorization , attestation , Flow control and so on .

you 're right , Middleware is to solve these things .

Let's take another look at a real case

stay DotnetCore In the project , Defining middleware is very convenient , Or the previous one 《》 The project in is a case , Now let's define a middleware , Let's take a look at the running effect （ Here are some cases written by GUI Suwei , I recommend you to read teacher GUI's article ）.

First , Create a class file , Just write a few lines of code , Pay attention to the

RequestDelegate

Is a delegate type , The explanation is also given in the official documents of Microsoft , This class , It is specially for processing http Born of request , Without it , The framework will lose its right HTTP The processing power of the request .

public class TestMiddleware1
{
 private readonly RequestDelegate _next;
 public TestMiddleware1(RequestDelegate next)
 {
 _next = next;
 }

 public async Task InvokeAsync(HttpContext context)
 {
 AnsiConsole.MarkupLine($"[red] I am the first 1 Middleware , I'm coming -{DateTime.Now}[/]");
 await _next(context);
 AnsiConsole.MarkupLine($"[red] I am the first 1 Middleware , I stepped down -{DateTime.Now}[/]");
 }
}

after , We are defining a static extension class to call the processing method of the pipeline

public static class TestMiddlewareExtensions
{
 public static void UseTest(this WebApplication app)
 {
 app.UseMiddleware<TestMiddleware1>();
 }
}

Last , In the main function （Program.cs perhaps StartUp.cs） Middleware is called in

var app = builder.Build();
... Other middleware
app.UseTest();

Look at the running effect .

Come here , Middleware has already started to work .

Define middleware , It can also be defined directly in the form of an expression , Write directly in the main function , However, this may cause the code to be unclear , But in some special cases, it is still necessary .

The code is as follows

var app = builder.Build();

app.UseTest();
app.Use(async (context, next) =>
{
 AnsiConsole.MarkupLine($"[Yellow] I am the first 2 Middleware , I come from the entry file , I'm coming -{DateTime.Now}[/]");
 await next(context);
 AnsiConsole.MarkupLine($"[Yellow] I am the first 2 Middleware , I come from the entry file , I stepped down -{DateTime.Now}[/]");
});

The operation effect is as follows

You can see , The execution order of middleware is different , Middleware registered first , Finally back to Response, This point is actually used

Pay attention , Don't get the order wrong , Especially those middleware that need to do some special business processing . On this point , You can see

Microsoft's official document

.

then , Let's go back to the first way to define middleware . When we need to define multiple middleware functions , Or should we try to put the middleware list into a separate file , This will make the code clearer . First example , If you register multiple middleware , You can do this

public class TestMiddleware1
{
 private readonly RequestDelegate _next;
 public TestMiddleware1(RequestDelegate next)
 {
 _next = next;
 }

 public async Task InvokeAsync(HttpContext context)
 {
 AnsiConsole.MarkupLine($"[red] I am the first 1 Middleware , I'm coming -{DateTime.Now}[/]");
 await _next(context);
 AnsiConsole.MarkupLine($"[red] I am the first 1 Middleware , I stepped down -{DateTime.Now}[/]");
 }
}

public class TestMiddleware2
{
 private readonly RequestDelegate _next;
 public TestMiddleware2(RequestDelegate next)
 {
 _next = next;
 }

 public async Task InvokeAsync(HttpContext context)
 {
 AnsiConsole.MarkupLine($"[green] I am the first 2 Middleware , I'm coming -{DateTime.Now}[/]");
 await _next(context);
 AnsiConsole.MarkupLine($"[green] I am the first 2 Middleware , I stepped down -{DateTime.Now}[/]");
 }
}

public class TestMiddleware3
{
 private readonly RequestDelegate _next;
 public TestMiddleware3(RequestDelegate next)
 {
 _next = next;
 }

 public async Task InvokeAsync(HttpContext context)
 {
 AnsiConsole.MarkupLine($"[blue] I am the first 3 Middleware , I'm coming -{DateTime.Now}[/]");
 await _next(context);
 AnsiConsole.MarkupLine($"[blue] I am the first 3 Middleware , I stepped down -{DateTime.Now}[/]");
 }
}


public static class TestMiddlewareExtensions
{
 public static void UseTest(this WebApplication app)
 {
 app.UseMiddleware<TestMiddleware1>();
 app.UseMiddleware<TestMiddleware2>();
 app.UseMiddleware<TestMiddleware3>();
 }
}

After running , The effect is like this

Okay , That's about it , The conversation is shallow , The specific example of middleware is just a little text , Actually, you need to write a log , Or monitoring or something , Just adjust it according to the actual business needs .

Good night ~