c# - current - ihttpcontextaccessor asp.net core 2

Registro de un nuevo DelegatingHandler en ASP.NET Core Web API

Question

Quiero crear un nuevo controlador que extienda DelegatingHandler para que pueda hacer cosas antes de llegar al controlador. He leído en varios lugares que necesito heredar de DelegatingHandler y luego invalidar a SendAsync () de esta manera:

public class ApiKeyHandler : DelegatingHandler
{        
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {          
        // do custom stuff here

        return base.SendAsync(request, cancellationToken);
    }
}

¡Todo esto está bien y es excelente, excepto que no hace nada porque no lo he registrado en ninguna parte! Una vez más, he visto en numerosos lugares que debería hacerlo en WebApiConfig.cs, pero eso no es parte de la versión ASP.NET Core de Web API. He intentado encontrar análogos entre las diversas cosas en el archivo Startup.cs (Configure (), ConfigureServices (), etc.) pero no he tenido suerte.

¿Alguien puede decirme cómo debo hacer para registrar mi nuevo controlador?

Answer 1

Como ya se mencionó en el comentario anterior, mira en Escribir tu propio middleware

Su ApiKeyHandler se puede convertir en una clase de middleware que toma el siguiente RequestDelegate en su constructor y admite un método Invoke como se muestra:

using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

namespace MyMiddlewareNamespace {

    public class ApiKeyMiddleware {
        private readonly RequestDelegate _next;
        private readonly ILogger _logger;
        private IApiKeyService _service;

        public ApiKeyMiddleware(RequestDelegate next, ILoggerFactory loggerFactory, IApiKeyService service) {
            _next = next;
            _logger = loggerFactory.CreateLogger<ApiKeyMiddleware>();
            _service = service
        }

        public async Task Invoke(HttpContext context) {
            _logger.LogInformation("Handling API key for: " + context.Request.Path);

            // do custom stuff here with service      

            await _next.Invoke(context);

            _logger.LogInformation("Finished handling api key.");
        }
    }
}

Middleware puede aprovechar la UseMiddleware<T> para inyectar servicios directamente en sus constructores, como se muestra en el siguiente ejemplo. Los servicios inyectados de dependencia se llenan automáticamente, y la extensión toma una matriz params de argumentos que se utilizarán para los parámetros no inyectados.

ApiKeyExtensions.cs

public static class ApiKeyExtensions {
    public static IApplicationBuilder UseApiKey(this IApplicationBuilder builder) {
        return builder.UseMiddleware<ApiKeyMiddleware>();
    }
}

Usando el método de extensión y la clase de middleware asociada, el método de Configurar se vuelve muy simple y legible.

public void Configure(IApplicationBuilder app) {
    //...other configuration

    app.UseApiKey();

    //...other configuration
}