Aktivace middlewaru na základě objektu pro vytváření v ASP.NET Core

  • Článek

Poznámka:

Toto není nejnovější verze tohoto článku. Aktuální verzi najdete ve verzi .NET 8 tohoto článku.

Upozorňující

Tato verze ASP.NET Core se už nepodporuje. Další informace najdete v tématu .NET a .NET Core Zásady podpory. Aktuální verzi najdete ve verzi .NET 8 tohoto článku.

Důležité

Tyto informace se týkají předběžného vydání produktu, který může být podstatně změněn před komerčním vydáním. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Aktuální verzi najdete ve verzi .NET 8 tohoto článku.

IMiddlewareFactory/IMiddleware je bod rozšiřitelnosti pro aktivaci middlewaru , který nabízí následující výhody:

  • Aktivace na požadavek klienta (injektáž služeb s vymezeným oborem)
  • Silné psaní middlewaru

UseMiddleware metody rozšíření zkontrolují, jestli se implementuje IMiddlewarezaregistrovaný typ middlewaru . Pokud ano, IMiddlewareFactory instance zaregistrovaná v kontejneru se používá k překladu IMiddleware implementace místo použití logiky aktivace middlewaru založené na konvenci. Middleware je zaregistrovaný jako vymezená nebo přechodná služba v kontejneru služby aplikace.

IMiddleware je aktivován na požadavek klienta (připojení), takže vymezené služby lze vložit do konstruktoru middlewaru.

IMiddleware

IMiddleware definuje middleware pro kanál žádosti aplikace. Metoda InvokeAsync(HttpContext, RequestDelegate) zpracovává požadavky a vrací metodu Task , která představuje spuštění middlewaru.

Middleware aktivovaný konvencí:

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 aktivovaný: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);
    }
}

Rozšíření se vytvářejí pro 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>();
}

Do middlewaru aktivovaného továrnou není možné předávat objekty pomocí 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);
}

Middleware aktivovaný továrnou se přidá do integrovaného kontejneru v Program.cs:

var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddTransient<FactoryActivatedMiddleware>();

Oba middleware jsou zaregistrované v kanálu zpracování požadavků, a to také v Program.cs:

var app = builder.Build();

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

IMiddlewareFactory

IMiddlewareFactory poskytuje metody pro vytvoření middlewaru. Implementace middlewarové továrny je zaregistrovaná v kontejneru jako vymezená služba.

Výchozí IMiddlewareFactory implementace , MiddlewareFactoryje nalezena v balíčku Microsoft.AspNetCore.Http .

Další materiály

IMiddlewareFactory/IMiddleware je bod rozšiřitelnosti pro aktivaci middlewaru .

UseMiddleware metody rozšíření zkontrolují, jestli se implementuje IMiddlewarezaregistrovaný typ middlewaru . Pokud ano, IMiddlewareFactory instance zaregistrovaná v kontejneru se používá k překladu IMiddleware implementace místo použití logiky aktivace middlewaru založené na konvenci. Middleware je zaregistrovaný jako vymezená nebo přechodná služba v kontejneru služby aplikace.

Výhody:

  • Aktivace na požadavek klienta (injektáž služeb s vymezeným oborem)
  • Silné psaní middlewaru

IMiddleware je aktivován na požadavek klienta (připojení), takže vymezené služby lze vložit do konstruktoru middlewaru.

Zobrazení nebo stažení ukázkového kódu (postup stažení)

IMiddleware

IMiddleware definuje middleware pro kanál žádosti aplikace. Metoda InvokeAsync(HttpContext, RequestDelegate) zpracovává požadavky a vrací metodu Task , která představuje spuštění middlewaru.

Middleware aktivovaný konvencí:

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 aktivovaný: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);
    }
}

Rozšíření se vytvářejí pro 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>();
    }
}

Do middlewaru aktivovaného továrnou není možné předávat objekty pomocí 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);
}

Middleware aktivovaný továrnou se přidá do integrovaného kontejneru v Startup.ConfigureServices:

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

    services.AddTransient<FactoryActivatedMiddleware>();

    services.AddRazorPages();
}

Oba middleware jsou zaregistrované v kanálu zpracování požadavků v 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 poskytuje metody pro vytvoření middlewaru. Implementace middlewarové továrny je zaregistrovaná v kontejneru jako vymezená služba.

Výchozí IMiddlewareFactory implementace , MiddlewareFactoryje nalezena v balíčku Microsoft.AspNetCore.Http .

Další materiály

IMiddlewareFactory/IMiddleware je bod rozšiřitelnosti pro aktivaci middlewaru .

UseMiddleware metody rozšíření zkontrolují, jestli se implementuje IMiddlewarezaregistrovaný typ middlewaru . Pokud ano, IMiddlewareFactory instance zaregistrovaná v kontejneru se používá k překladu IMiddleware implementace místo použití logiky aktivace middlewaru založené na konvenci. Middleware je zaregistrovaný jako vymezená nebo přechodná služba v kontejneru služby aplikace.

Výhody:

  • Aktivace na požadavek klienta (injektáž služeb s vymezeným oborem)
  • Silné psaní middlewaru

IMiddleware je aktivován na požadavek klienta (připojení), takže vymezené služby lze vložit do konstruktoru middlewaru.

Zobrazení nebo stažení ukázkového kódu (postup stažení)

IMiddleware

IMiddleware definuje middleware pro kanál žádosti aplikace. Metoda InvokeAsync(HttpContext, RequestDelegate) zpracovává požadavky a vrací metodu Task , která představuje spuštění middlewaru.

Middleware aktivovaný konvencí:

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 aktivovaný: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);
    }
}

Rozšíření se vytvářejí pro 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>();
    }
}

Do middlewaru aktivovaného továrnou není možné předávat objekty pomocí 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);
}

Middleware aktivovaný továrnou se přidá do integrovaného kontejneru v Startup.ConfigureServices:

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

    services.AddTransient<FactoryActivatedMiddleware>();

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

Oba middleware jsou zaregistrované v kanálu zpracování požadavků v 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 poskytuje metody pro vytvoření middlewaru. Implementace middlewarové továrny je zaregistrovaná v kontejneru jako vymezená služba.

Výchozí IMiddlewareFactory implementace , MiddlewareFactoryje nalezena v balíčku Microsoft.AspNetCore.Http .

Další materiály