Delen via

Middlewareactivering op basis van factory in ASP.NET Core

Note

Dit is niet de nieuwste versie van dit artikel. Zie de .NET 9-versie van dit artikel voor de huidige release.

Warning

Deze versie van ASP.NET Core wordt niet meer ondersteund. Zie het .NET- en .NET Core-ondersteuningsbeleid voor meer informatie. Zie de .NET 9-versie van dit artikel voor de huidige release.

Important

Deze informatie heeft betrekking op een pre-releaseproduct dat aanzienlijk kan worden gewijzigd voordat het commercieel wordt uitgebracht. Microsoft geeft geen garanties, uitdrukkelijk of impliciet, met betrekking tot de informatie die hier wordt verstrekt.

Zie de .NET 9-versie van dit artikel voor de huidige release.

IMiddlewareFactory / IMiddleware is een uitbreidbaarheidspunt voor de activering van middleware dat de volgende voordelen biedt:

  • Activering per aanvraag van de cliënt (injectie van scoped services)
  • Sterke typeclassificatie van middleware

UseMiddleware extensiemethoden controleren of het geregistreerde type van een middleware wordt geïmplementeerd IMiddleware. Als dit het geval is, wordt het IMiddlewareFactory exemplaar dat is geregistreerd in de container gebruikt om de IMiddleware implementatie op te lossen in plaats van de op conventie gebaseerde middlewareactiveringslogica te gebruiken. De middleware wordt geregistreerd als een scoped of tijdelijke service in de servicecontainer van de app.

IMiddleware wordt geactiveerd per clientaanvraag (verbinding), zodat scoped services kunnen worden geïnjecteerd in de constructor van de middleware.

IMiddleware

IMiddleware definieert middleware voor de aanvraagpijplijn van de app. De methode InvokeAsync(HttpContext, RequestDelegate) verwerkt aanvragen en retourneert een Task methode die de uitvoering van de middleware vertegenwoordigt.

Middleware geactiveerd volgens conventie:

public class ConventionalMiddleware
{
    private readonly RequestDelegate _next;

    public ConventionalMiddleware(RequestDelegate next)
        => _next = next;

    public async Task InvokeAsync(HttpContext context, SampleDbContext dbContext)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            dbContext.Requests.Add(new Request("Conventional", keyValue));

            await dbContext.SaveChangesAsync();
        }

        await _next(context);
    }
}

Middleware geactiveerd door MiddlewareFactory:

public class FactoryActivatedMiddleware : IMiddleware
{
    private readonly SampleDbContext _dbContext;

    public FactoryActivatedMiddleware(SampleDbContext dbContext)
        => _dbContext = dbContext;

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            _dbContext.Requests.Add(new Request("Factory", keyValue));

            await _dbContext.SaveChangesAsync();
        }

        await next(context);
    }
}

Extensies worden gemaakt voor de middleware:

public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseConventionalMiddleware(
        this IApplicationBuilder app)
        => app.UseMiddleware<ConventionalMiddleware>();

    public static IApplicationBuilder UseFactoryActivatedMiddleware(
        this IApplicationBuilder app)
        => app.UseMiddleware<FactoryActivatedMiddleware>();
}

Het is niet mogelijk om objecten door te geven aan de door de fabriek geactiveerde middleware met UseMiddleware:

public static IApplicationBuilder UseFactoryActivatedMiddleware(
    this IApplicationBuilder app, bool option)
{
    // Passing 'option' as an argument throws a NotSupportedException at runtime.
    return app.UseMiddleware<FactoryActivatedMiddleware>(option);
}

De fabrieksgeactiveerde middleware wordt toegevoegd aan de ingebouwde container in Program.cs.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<SampleDbContext>
    (options => options.UseInMemoryDatabase("SampleDb"));

builder.Services.AddTransient<FactoryActivatedMiddleware>();

Beide middleware zijn geregistreerd in de aanvraagverwerkingspijplijn, ook in Program.cs:

var app = builder.Build();

app.UseConventionalMiddleware();
app.UseFactoryActivatedMiddleware();

IMiddlewareFactory

IMiddlewareFactory biedt methoden voor het maken van middleware. De implementatie van de middleware factory wordt geregistreerd in de container als een scoped service.

De standaard IMiddlewareFactory implementatie vindt MiddlewareFactoryu in het Pakket Microsoft.AspNetCore.Http .

Aanvullende bronnen

IMiddlewareFactory / IMiddleware is een uitbreidbaarheidspunt voor de activering van middleware.

UseMiddleware extensiemethoden controleren of het geregistreerde type van een middleware wordt geïmplementeerd IMiddleware. Als dit het geval is, wordt het IMiddlewareFactory exemplaar dat is geregistreerd in de container gebruikt om de IMiddleware implementatie op te lossen in plaats van de op conventie gebaseerde middlewareactiveringslogica te gebruiken. De middleware wordt geregistreerd als een scoped of tijdelijke service in de servicecontainer van de app.

Benefits:

  • Activering per aanvraag van de cliënt (injectie van scoped services)
  • Sterke typeclassificatie van middleware

IMiddleware wordt geactiveerd per clientaanvraag (verbinding), zodat scoped services kunnen worden geïnjecteerd in de constructor van de middleware.

Voorbeeldcode bekijken of downloaden (hoe download je)

IMiddleware

IMiddleware definieert middleware voor de aanvraagpijplijn van de app. De methode InvokeAsync(HttpContext, RequestDelegate) verwerkt aanvragen en retourneert een Task methode die de uitvoering van de middleware vertegenwoordigt.

Middleware geactiveerd volgens conventie:

public class ConventionalMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context, AppDbContext db)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            db.Add(new Request()
                {
                    DT = DateTime.UtcNow, 
                    MiddlewareActivation = "ConventionalMiddleware", 
                    Value = keyValue
                });

            await db.SaveChangesAsync();
        }

        await _next(context);
    }
}

Middleware geactiveerd door MiddlewareFactory:

public class FactoryActivatedMiddleware : IMiddleware
{
    private readonly AppDbContext _db;

    public FactoryActivatedMiddleware(AppDbContext db)
    {
        _db = db;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            _db.Add(new Request()
                {
                    DT = DateTime.UtcNow, 
                    MiddlewareActivation = "FactoryActivatedMiddleware", 
                    Value = keyValue
                });

            await _db.SaveChangesAsync();
        }

        await next(context);
    }
}

Extensies worden gemaakt voor de middleware:

public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseConventionalMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<ConventionalMiddleware>();
    }

    public static IApplicationBuilder UseFactoryActivatedMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<FactoryActivatedMiddleware>();
    }
}

Het is niet mogelijk om objecten door te geven aan de door de fabriek geactiveerde middleware met UseMiddleware:

public static IApplicationBuilder UseFactoryActivatedMiddleware(
    this IApplicationBuilder builder, bool option)
{
    // Passing 'option' as an argument throws a NotSupportedException at runtime.
    return builder.UseMiddleware<FactoryActivatedMiddleware>(option);
}

De fabrieksgeactiveerde middleware wordt toegevoegd aan de ingebouwde container in Startup.ConfigureServices.

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<AppDbContext>(options =>
        options.UseInMemoryDatabase("InMemoryDb"));

    services.AddTransient<FactoryActivatedMiddleware>();

    services.AddRazorPages();
}

Beide middleware zijn geregistreerd in de pijplijn voor aanvraagverwerking in Startup.Configure:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
    }

    app.UseConventionalMiddleware();
    app.UseFactoryActivatedMiddleware();

    app.UseStaticFiles();
    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}

IMiddlewareFactory

IMiddlewareFactory biedt methoden voor het maken van middleware. De implementatie van de middleware factory wordt geregistreerd in de container als een scoped service.

De standaard IMiddlewareFactory implementatie vindt MiddlewareFactoryu in het Pakket Microsoft.AspNetCore.Http .

Aanvullende bronnen

IMiddlewareFactory / IMiddleware is een uitbreidbaarheidspunt voor de activering van middleware.

UseMiddleware extensiemethoden controleren of het geregistreerde type van een middleware wordt geïmplementeerd IMiddleware. Als dit het geval is, wordt het IMiddlewareFactory exemplaar dat is geregistreerd in de container gebruikt om de IMiddleware implementatie op te lossen in plaats van de op conventie gebaseerde middlewareactiveringslogica te gebruiken. De middleware wordt geregistreerd als een scoped of tijdelijke service in de servicecontainer van de app.

Benefits:

  • Activering per aanvraag van de cliënt (injectie van scoped services)
  • Sterke typeclassificatie van middleware

IMiddleware wordt geactiveerd per clientaanvraag (verbinding), zodat scoped services kunnen worden geïnjecteerd in de constructor van de middleware.

Voorbeeldcode bekijken of downloaden (hoe download je)

IMiddleware

IMiddleware definieert middleware voor de aanvraagpijplijn van de app. De methode InvokeAsync(HttpContext, RequestDelegate) verwerkt aanvragen en retourneert een Task methode die de uitvoering van de middleware vertegenwoordigt.

Middleware geactiveerd volgens conventie:

public class ConventionalMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context, AppDbContext db)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            db.Add(new Request()
                {
                    DT = DateTime.UtcNow, 
                    MiddlewareActivation = "ConventionalMiddleware", 
                    Value = keyValue
                });

            await db.SaveChangesAsync();
        }

        await _next(context);
    }
}

Middleware geactiveerd door MiddlewareFactory:

public class FactoryActivatedMiddleware : IMiddleware
{
    private readonly AppDbContext _db;

    public FactoryActivatedMiddleware(AppDbContext db)
    {
        _db = db;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var keyValue = context.Request.Query["key"];

        if (!string.IsNullOrWhiteSpace(keyValue))
        {
            _db.Add(new Request()
                {
                    DT = DateTime.UtcNow, 
                    MiddlewareActivation = "FactoryActivatedMiddleware", 
                    Value = keyValue
                });

            await _db.SaveChangesAsync();
        }

        await next(context);
    }
}

Extensies worden gemaakt voor de middleware:

public static class MiddlewareExtensions
{
    public static IApplicationBuilder UseConventionalMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<ConventionalMiddleware>();
    }

    public static IApplicationBuilder UseFactoryActivatedMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<FactoryActivatedMiddleware>();
    }
}

Het is niet mogelijk om objecten door te geven aan de door de fabriek geactiveerde middleware met UseMiddleware:

public static IApplicationBuilder UseFactoryActivatedMiddleware(
    this IApplicationBuilder builder, bool option)
{
    // Passing 'option' as an argument throws a NotSupportedException at runtime.
    return builder.UseMiddleware<FactoryActivatedMiddleware>(option);
}

De fabrieksgeactiveerde middleware wordt toegevoegd aan de ingebouwde container in Startup.ConfigureServices.

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<AppDbContext>(options =>
        options.UseInMemoryDatabase("InMemoryDb"));

    services.AddTransient<FactoryActivatedMiddleware>();

    services.AddMvc()
        .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Beide middleware zijn geregistreerd in de pijplijn voor aanvraagverwerking in Startup.Configure:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
    }

    app.UseConventionalMiddleware();
    app.UseFactoryActivatedMiddleware();

    app.UseStaticFiles();
    app.UseMvc();
}

IMiddlewareFactory

IMiddlewareFactory biedt methoden voor het maken van middleware. De implementatie van de middleware factory wordt geregistreerd in de container als een scoped service.

De standaard IMiddlewareFactory implementatie vindt MiddlewareFactoryu in het Pakket Microsoft.AspNetCore.Http .

Aanvullende bronnen