Dela via

Fabriksbaserad aktivering av mellanprogram i ASP.NET Core

Note

Det här är inte den senaste versionen av den här artikeln. För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

Warning

Den här versionen av ASP.NET Core stöds inte längre. Mer information finns i supportpolicyn för .NET och .NET Core. För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

Important

Den här informationen gäller en förhandsversionsprodukt som kan ändras avsevärt innan den släpps kommersiellt. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, med avseende på den information som tillhandahålls här.

För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

IMiddlewareFactory / IMiddleware är en utökningspunkt för aktivering av mellanprogram som erbjuder följande fördelar:

  • Aktivering per klientbegäran (injektion av avgränsade tjänster)
  • Stark typning av mellanprogram

UseMiddleware tilläggsmetoder kontrollerar om en mellanvarans registrerade typ implementerar IMiddleware. Om den gör det används den IMiddlewareFactory instans som är registrerad i containern för att lösa IMiddleware implementeringen i stället för att använda den konventionsbaserade aktiveringslogik för mellanprogram. Mellanprogrammet registreras som en begränsad eller tillfällig tjänst i appens tjänstcontainer.

IMiddleware aktiveras per klientbegäran (anslutning), så begränsade tjänster kan matas in i mellanprogrammets konstruktor.

IMiddleware

IMiddleware definierar mellanprogram för appens pipeline för begäranden. Metoden InvokeAsync(HttpContext, RequestDelegate) hanterar begäranden och returnerar en Task som representerar körningen av mellanprogrammet.

Mellanprogram som aktiveras av konventionen:

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);
    }
}

Mellanprogram som aktiveras av 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);
    }
}

Tillägg skapas för mellanprogrammet:

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

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

Det går inte att skicka objekt till det fabriksaktiverade mellanprogrammet med 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);
}

Det fabriksaktiverade mellanprogrammet läggs till i den inbyggda containern i Program.cs:

var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddTransient<FactoryActivatedMiddleware>();

Båda mellanprogram registreras i pipelinen för bearbetning av begäranden, även i Program.cs:

var app = builder.Build();

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

IMiddlewareFactory

IMiddlewareFactory tillhandahåller metoder för att skapa mellanprogram. Implementeringen av mellanprogramfabriken registreras i containern som en begränsad tjänst.

Standardimplementeringen IMiddlewareFactory , MiddlewareFactory, finns i paketet Microsoft.AspNetCore.Http .

Ytterligare resurser

IMiddlewareFactory / IMiddleware är en utökningspunkt för aktivering av mellanprogram .

UseMiddleware tilläggsmetoder kontrollerar om en mellanvarans registrerade typ implementerar IMiddleware. Om den gör det används den IMiddlewareFactory instans som är registrerad i containern för att lösa IMiddleware implementeringen i stället för att använda den konventionsbaserade aktiveringslogik för mellanprogram. Mellanprogrammet registreras som en begränsad eller tillfällig tjänst i appens tjänstcontainer.

Benefits:

  • Aktivering per klientbegäran (injektion av avgränsade tjänster)
  • Stark typning av mellanprogram

IMiddleware aktiveras per klientbegäran (anslutning), så begränsade tjänster kan matas in i mellanprogrammets konstruktor.

Visa eller ladda ned exempelkod (hur du laddar ned)

IMiddleware

IMiddleware definierar mellanprogram för appens pipeline för begäranden. Metoden InvokeAsync(HttpContext, RequestDelegate) hanterar begäranden och returnerar en Task som representerar körningen av mellanprogrammet.

Mellanprogram som aktiveras av konventionen:

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);
    }
}

Mellanprogram som aktiveras av 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);
    }
}

Tillägg skapas för mellanprogrammet:

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>();
    }
}

Det går inte att skicka objekt till det fabriksaktiverade mellanprogrammet med 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);
}

Det fabriksaktiverade mellanprogrammet läggs till i den inbyggda containern i Startup.ConfigureServices:

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

    services.AddTransient<FactoryActivatedMiddleware>();

    services.AddRazorPages();
}

Båda mellanprogram registreras i pipelinen för bearbetning av begäran i 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 tillhandahåller metoder för att skapa mellanprogram. Implementeringen av mellanprogramfabriken registreras i containern som en begränsad tjänst.

Standardimplementeringen IMiddlewareFactory , MiddlewareFactory, finns i paketet Microsoft.AspNetCore.Http .

Ytterligare resurser

IMiddlewareFactory / IMiddleware är en utökningspunkt för aktivering av mellanprogram .

UseMiddleware tilläggsmetoder kontrollerar om en mellanvarans registrerade typ implementerar IMiddleware. Om den gör det används den IMiddlewareFactory instans som är registrerad i containern för att lösa IMiddleware implementeringen i stället för att använda den konventionsbaserade aktiveringslogik för mellanprogram. Mellanprogrammet registreras som en begränsad eller tillfällig tjänst i appens tjänstcontainer.

Benefits:

  • Aktivering per klientbegäran (injektion av avgränsade tjänster)
  • Stark typning av mellanprogram

IMiddleware aktiveras per klientbegäran (anslutning), så begränsade tjänster kan matas in i mellanprogrammets konstruktor.

Visa eller ladda ned exempelkod (hur du laddar ned)

IMiddleware

IMiddleware definierar mellanprogram för appens pipeline för begäranden. Metoden InvokeAsync(HttpContext, RequestDelegate) hanterar begäranden och returnerar en Task som representerar körningen av mellanprogrammet.

Mellanprogram som aktiveras av konventionen:

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);
    }
}

Mellanprogram som aktiveras av 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);
    }
}

Tillägg skapas för mellanprogrammet:

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>();
    }
}

Det går inte att skicka objekt till det fabriksaktiverade mellanprogrammet med 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);
}

Det fabriksaktiverade mellanprogrammet läggs till i den inbyggda containern i Startup.ConfigureServices:

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

    services.AddTransient<FactoryActivatedMiddleware>();

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

Båda mellanprogram registreras i pipelinen för bearbetning av begäran i 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 tillhandahåller metoder för att skapa mellanprogram. Implementeringen av mellanprogramfabriken registreras i containern som en begränsad tjänst.

Standardimplementeringen IMiddlewareFactory , MiddlewareFactory, finns i paketet Microsoft.AspNetCore.Http .

Ytterligare resurser