Shulou(Shulou.com)06/01 Report--

Net Core development is what the practice of Middleware is, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain for you in detail, people with this need can come to learn, I hope you can gain something.

Developers familiar with ASP.NET architecture must be familiar with HTTP Modules and HTTP Handlers. The main function of both is to perform specific processing work on network requests. In the .NET Core, they are all replaced by Middleware.

The previous Http Modules and HTTP Handlers handled the request as follows:

Now it's like this:

In a word, Middleware has completed the original work of HTTP Modules and HTTP Handlers, but it is not a simple subtraction of two into one.

What Middleware subtracts is actually a binding to application lifecycle events (application life cycle event), an important foundation of the original ASP.NET.

When HTTP Modules is initialized, it needs to bind to the events of HttpApplication, so that when the events of HttpApplication are triggered, the bound handlers will be executed as expected.

Public class HelloWorldModule: IHttpModule {public HelloWorldModule () {} public String ModuleName {get {return "HelloWorldModule";}} / In the Init function, register for HttpApplication / / events by adding your handlers. Public void Init (HttpApplication application) {application.BeginRequest + = (new EventHandler (this.Application_BeginRequest)); application.EndRequest + = (new EventHandler (this.Application_EndRequest));} private void Application_BeginRequest (Object source, EventArgs e) {/ / Create HttpApplication and HttpContext objects to access / / request and response properties. HttpApplication application = (HttpApplication) source; HttpContext context = application.Context; context.Response.Write ("HelloWorldModule: Beginning of Request");} private void Application_EndRequest (Object source, EventArgs e) {HttpApplication application = (HttpApplication) source; HttpContext context = application.Context; context.Response.Write ("HelloWorldModule: End of Request") } public void Dispose () {}}

Then you need to register the HTTP Module in the web.config configuration file.

If you use Middleware, things will be very simple. Get rid of the IHttpModule interface and HttpModule implementation classes, no longer care about any events of HttpApplication, and annoying web.config configuration. Work is done directly in the code in the most concise way.

Public void Configure (IApplicationBuilder app, IHostingEnvironment env) {app.Use (async (context, next) = > {

Await context.Response.WriteAsync ("Beginning of Request\ n")

Await next.Invoke ()

Await context.Response.WriteAsync ("End of Request\ n");}); app.Run (async (context) = > {await context.Response.WriteAsync ("Hello World!\ n");});}

Similarly, for HTTP Handlers, although it is not necessary to remove the dependence on HttpApplication events, Middleware has no doubt that it is better than the two in terms of their code implementation.

Public class HelloWorldHandler: IHttpHandler {

Public HelloWorldHandler () {}

Public void ProcessRequest (HttpContext context) {HttpRequest Request = context.Request; HttpResponse Response = context.Response; / / This handler is called whenever a file ending / / in. Sample is requested. A file with that extension / / does not need to exist. Response.Write ("); Response.Write ("); Response.Write ("Hello from a synchronous custom HTTP handler."); Response.Write (""); Response.Write ("");}

Public bool IsReusable {/ / To enable pooling, return true here. / / This keeps the handler in memory. Get {return false;}

You still need to register HTTP handler in the web.config file.

In other words, Middleware:

Private static void HandleSample (IApplicationBuilder app) {app.Run (async context = > {await context.Response.WriteAsync ("Hello Sample");});}

/ / This method gets called by the runtime. Use this method to configure the HTTP request pipeline.

Public void Configure (IApplicationBuilder app, IHostingEnvironment env) {app.MapWhen (context = > context.Request.Path.Value.EndsWith ("sample"), HandleSample);}

Advantages of using Middleware:

No dependence on HttpApplication

No dependence on IHttpModule and IHttpHandler interfaces

There is no need to add various configurations to the web.config file

The code is concise

Finally, you need to add a little difference between Middleware and HTTP Modules. The order in which requests and responses are processed in each Middleware is just the opposite, and the earlier the request is processed, the later the Middleware processes the response. The order in which requests and responses are processed in HTTP Modules remains the same, because the binding of each HTTP Module request and response event is done at the same stage.

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.