Ativação de middleware baseada em fábrica no ASP.NET Core

IMiddlewareFactory / IMiddleware é um ponto de extensibilidade para ativação de middleware que oferece os seguintes benefícios:

• Ativação por solicitação de clientes (injeção de serviços delimitados)
• Tipagem forte de middleware

UseMiddleware Os métodos de extensão verificam se o tipo registado de um middleware implementa IMiddleware. Se isso acontecer, a IMiddlewareFactory instância registrada no contêiner será usada para resolver a IMiddleware implementação em vez de usar a lógica de ativação de middleware baseada em convenção. O middleware é registrado como um serviço com escopo ou transitório no contêiner de serviço do aplicativo.

IMiddleware é ativado por solicitação do cliente (conexão), permitindo que os serviços com escopo sejam injetados no constructor do middleware.

IMiddleware

IMiddleware Define middleware para o pipeline de solicitação do aplicativo. O método InvokeAsync(HttpContext, RequestDelegate) manipula solicitações e retorna um Task que representa a execução do middleware.

Middleware ativado por convenção:

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

As extensões são criadas para o 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>();
}

Não é possível passar objetos para o middleware ativado de fábrica com 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);
}

O middleware ativado de fábrica é adicionado ao contentor integrado em Program.cs:

var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddTransient<FactoryActivatedMiddleware>();

Ambos os middleware são registrados no pipeline de processamento de solicitações, também em Program.cs:

var app = builder.Build();

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

IMiddlewareFactory

IMiddlewareFactory Fornece métodos para criar middleware. A implementação da fábrica de middleware é registrada no contêiner como um serviço com escopo.

A implementação padrão IMiddlewareFactory , MiddlewareFactory, é encontrada no pacote Microsoft.AspNetCore.Http .

Recursos adicionais

• Visualizar ou descarregar amostra de código (como descarregar)
• ASP.NET Middleware principal
• ativação do middleware com um contêiner de terceiros no ASP.NET Core