How you can use factory-based middleware activation in ASP.NET Core

When constructing ASP.NET Core purposes, you possibly can make the most of varied middleware parts to examine, route, or modify the request and response messages flowing by way of the pipeline. It’s also possible to write your individual customized middleware in ASP.NET Core.

Utility pipelines in ASP.NET Core usually have a set of middleware parts. On this article, we’ll have a look at how middleware in ASP.NET Core can work along with convention-based and factory-based approaches.

To make use of the code examples supplied on this article, it’s essential to have Visible Studio 2022 put in in your system. If you happen to do not have already got a duplicate, you possibly can obtain Visible Studio 2022 right here.

Create an ASP.NET Core 7 Internet API mission in Visible Studio 2022

First, let’s create an ASP.NET Core 7 mission in Visible Studio 2022. Comply with these steps:

1. Begin the Visible Studio 2022 IDE.
2. Click on Create new mission.
3. Within the Create New Undertaking window, choose ASP.NET Core Internet API from the record of templates displayed.
4. Click on Subsequent.
5. Within the Configure New Undertaking window, specify a reputation and placement in your new mission.
6. Optionally, test the “Place answer and mission in the identical listing” checkbox, relying in your preferences.
7. Click on Subsequent.
8. Within the Further Data window that seems subsequent, go away the Use Controller (uncheck to make use of minimal API) checkbox. This mission doesn’t use the minimal API. Depart Authentication Kind set to None (default).
9. Make certain the Allow Open API Assist, Configure for HTTPS, and Allow Docker checkboxes are left unchecked, as we can’t be utilizing these options right here.
10. Click on Create.

Within the following sections, we’ll use this ASP.NET Core 7 Internet API mission to work with factory-based middleware activation.

Perceive middleware in ASP.NET Core

Middleware are software program parts that make up the request/response processing pipeline in ASP.NET Core. Incoming requests move by way of every middleware part within the pipeline, and every of these parts can course of the request or ahead the request to the following part within the pipeline.

There are a lot of issues middleware can do, comparable to authentication, authorization, logging, exception dealing with, routing, caching, and response compression. You may modularize your utility’s performance into separate parts and add, take away, or rearrange middleware to tailor the request and response processing pipeline to your utility.

Historically, when utilizing newer variations of ASP.NET Core, you needed to configure middleware parts utilizing the UseMiddleware extension methodology within the Startup class or the Program.cs file. In distinction, factory-based middleware activation lets you outline and configure middleware parts utilizing factories, which provides you extra flexibility in activation.

Be aware that for those who do not create a customized middleware manufacturing unit class, the default middleware manufacturing unit will probably be used. ASP.NET Core lets you activate middleware in two alternative ways: convention-based middleware activation and factory-based middleware activation. Let’s contemplate each approaches right here.

Conference-based middleware in ASP.NET Core

Conference-Based mostly Middleware Activation in ASP.NET Core is a characteristic that lets you mechanically apply middleware to the request/response pipeline based mostly on predefined conventions as an alternative of explicitly configuring every middleware part . The next code itemizing exhibits find out how to create a convention-based middleware part.

public class ConventionalMiddleware
    {
        non-public readonly RequestDelegate _next;
        public ConventionalMiddleware(RequestDelegate subsequent)
            => _next = subsequent;
        public async Job InvokeAsync(HttpContext context)
        {
            Hint.WriteLine("Contained in the Standard Middleware.");
            await _next(context);
        }
    }

You may add this middleware to your request processing pipeline with the next code in your Program.cs file:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Construct();
app.UseMiddleware<ConventionalMiddleware>();
app.Run();

Manufacturing facility-based middleware in ASP.NET Core

Manufacturing facility-based middleware activation in ASP.NET Core offers a extra versatile and dynamic method to configure and activate middleware parts. Manufacturing facility-based middleware activation lets you customise the middleware instantiation course of based mostly in your utility wants.

Manufacturing facility-based middleware lets you inject lifetime-limited dependencies utilizing the middleware class constructor. This characteristic will not be supported by convention-based middleware. A scoped lifetime signifies that the service is created as soon as per consumer request and destroyed when the request ends.

Manufacturing facility-based middleware has the next benefits over traditional-style or convention-based middleware:

• Contract-based middleware is created as soon as when the ASP.NET Core utility begins, whereas factory-based middleware is created per request.
• Manufacturing facility-based middleware offers per-request activation help, so scoped companies could be injected into the middleware’s constructor.
• Manufacturing facility-based middleware promotes sturdy typing of middleware varieties.

To make use of factory-based middleware activation, it’s essential to comply with 4 steps outlined beneath.

1. Create a category to signify your middleware part and implement the IMiddleware interface.
2. Implement an InvokeAsync methodology in your middleware that defines the middleware’s logic.
3. Add middleware to the DI container utilizing the AddSingleton or AddScoped strategies.
4. Use the UseMiddleware extension methodology and specify the middleware part kind to configure the middleware pipeline.

The next code itemizing exhibits find out how to create a factory-based middleware part.

    public class FactoryActivatedMiddleware : IMiddleware
    {
        public async Job InvokeAsync(HttpContext context,
        RequestDelegate subsequent)
        {
            Hint.WriteLine("Contained in the Manufacturing facility Activated Middleware.");
            await subsequent.Invoke(context);
        }
    }

It’s good to register the middleware with the service container utilizing the next code.

var builder = WebApplication.CreateBuilder(args);
builder.Providers.AddTransient<FactoryActivatedMiddleware>();

Now you can add this middleware in a lot the identical means you added it within the convention-based middleware instance.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Construct();
app.UseMiddleware<FactoryActivatedMiddleware>();
app.Run();

Every name to the UseMiddleware extension methodology checks whether or not the middleware implementation in query conforms to the IMiddleware interface. If this situation is met, the occasion of IMiddlewareFactory registered within the service container will probably be used to resolve his IMiddleware interface implementation as an alternative of the contract-based middleware implementation. This middleware is registered as a transient or scoped service throughout the service container.

The IMiddlewareFactory interface defines two strategies, the Create(Kind) methodology and the Launch(IMiddleware) methodology. The Create(Kind) methodology is used to create a middleware occasion for every request, whereas the Launch(IMiddleware) methodology releases her IMiddleware occasion on the finish of the request. A default implementation of IMiddlewareFactory is on the market within the Microsoft.AspNetCore.Http.MiddlewareFactory class.