Skriva anpassade ASP.NET Core-mellanprogram

2025-06-27

Anmärkning

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 .

Varning

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 .

Viktigt!

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 .

Av Fiyaz Hasan, Rick Anderson och Steve Smith

Mellanprogram är programvara som monteras i en apppipeline för att hantera begäranden och svar. ASP.NET Core innehåller en omfattande uppsättning inbyggda mellanprogramskomponenter, men i vissa scenarier kanske du vill skriva ett anpassat mellanprogram.

I det här avsnittet beskrivs hur du skriver konventionsbaserade mellanprogram. En metod som använder stark typning och aktivering per begäran finns i Fabriksbaserad aktivering av mellanprogram i ASP.NET Core.

Mellanprogramsklass

Mellanprogram kapslas vanligtvis in i en klass och exponeras med en tilläggsmetod. Överväg följande infogade mellanprogram, som anger kulturen för den aktuella begäran från en frågesträng:

using System.Globalization;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseHttpsRedirection();

app.Use(async (context, next) =>
{
    var cultureQuery = context.Request.Query["culture"];
    if (!string.IsNullOrWhiteSpace(cultureQuery))
    {
        var culture = new CultureInfo(cultureQuery);

        CultureInfo.CurrentCulture = culture;
        CultureInfo.CurrentUICulture = culture;
    }

    // Call the next delegate/middleware in the pipeline.
    await next(context);
});

app.Run(async (context) =>
{
    await context.Response.WriteAsync(
        $"CurrentCulture.DisplayName: {CultureInfo.CurrentCulture.DisplayName}");
});

app.Run();

Det markerade föregående inline-mellanprogrammet används för att demonstrera hur man skapar en mellanprogramskomponent genom att anropa Microsoft.AspNetCore.Builder.UseExtensions.Use. Den föregående Use tilläggsmetoden lägger till ett mellanprogramsdelegat som definierats i pipelinen för programbegäran.

Det finns två överlagringar för tillägget Use:

Man tar en HttpContext och en Func<Task>. Anropa Func<Task> utan några parametrar.
Den andra tar en HttpContext och en RequestDelegate. Anropa RequestDelegate genom att skicka HttpContext.

Föredra att använda den senare överbelastningen eftersom det sparar två interna allokeringar per förfrågan som krävs när du använder den andra överbelastningen.

Testa mellanprogrammet genom att skicka in kulturinställningen. Du kan till exempel begära https://localhost:5001/?culture=es-es.

Information om ASP.NET Cores inbyggda lokaliseringsstöd finns i Globalisering och lokalisering i ASP.NET Core.

Följande kod flyttar mellanprogramsdelegaten till en klass:

using System.Globalization;

namespace Middleware.Example;

public class RequestCultureMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        var cultureQuery = context.Request.Query["culture"];
        if (!string.IsNullOrWhiteSpace(cultureQuery))
        {
            var culture = new CultureInfo(cultureQuery);

            CultureInfo.CurrentCulture = culture;
            CultureInfo.CurrentUICulture = culture;
        }

        // Call the next delegate/middleware in the pipeline.
        await _next(context);
    }
}

Mellanprogramsklassen måste innehålla:

En offentlig konstruktor med en parameter av typen RequestDelegate.
En offentlig metod med namnet Invoke eller InvokeAsync. Den här metoden måste:
- Returnera en Task.
- Acceptera en första parameter av typen HttpContext.

Ytterligare parametrar för konstruktorn och Invoke/InvokeAsync fylls i av beroendeinmatning (DI).

Vanligtvis skapas en tilläggsmetod för att exponera mellanprogrammet via IApplicationBuilder:

using System.Globalization;

namespace Middleware.Example;

public class RequestCultureMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        var cultureQuery = context.Request.Query["culture"];
        if (!string.IsNullOrWhiteSpace(cultureQuery))
        {
            var culture = new CultureInfo(cultureQuery);

            CultureInfo.CurrentCulture = culture;
            CultureInfo.CurrentUICulture = culture;
        }

        // Call the next delegate/middleware in the pipeline.
        await _next(context);
    }
}

public static class RequestCultureMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestCulture(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestCultureMiddleware>();
    }
}

Följande kod anropar mellanprogrammet från Program.cs:

using Middleware.Example;
using System.Globalization;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseHttpsRedirection();

app.UseRequestCulture();

app.Run(async (context) =>
{
    await context.Response.WriteAsync(
        $"CurrentCulture.DisplayName: {CultureInfo.CurrentCulture.DisplayName}");
});

app.Run();

Beroenden för mellanprogram

Mellanprogram bör följa principen explicita beroenden genom att exponera dess beroenden i konstruktorn. Mellanprogram konstrueras en gång per programlivslängd.

Mellanprogramskomponenter kan lösa sina beroenden från beroendeinmatning (DI) via konstruktorparametrar. UseMiddleware kan också acceptera ytterligare parametrar direkt.

Beroenden för mellanprogram per begäran

Mellanprogram konstrueras vid appstart och har därför programlivstid. Tjänster med begränsad livstid som används av mellanprogramskonstruktorer delas inte med andra typer som injiceras som beroenden för varje begäran. Om du vill dela en begränsad tjänst mellan mellanprogram och andra typer lägger du till dessa tjänster i InvokeAsync metodens signatur. Metoden InvokeAsync kan acceptera ytterligare parametrar som fylls i av DI:

namespace Middleware.Example;

public class MyCustomMiddleware
{
    private readonly RequestDelegate _next;

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

    // IMessageWriter is injected into InvokeAsync
    public async Task InvokeAsync(HttpContext httpContext, IMessageWriter svc)
    {
        svc.Write(DateTime.Now.Ticks.ToString());
        await _next(httpContext);
    }
}

public static class MyCustomMiddlewareExtensions
{
    public static IApplicationBuilder UseMyCustomMiddleware(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<MyCustomMiddleware>();
    }
}

Alternativen för livslängd och registrering innehåller ett komplett urval av mellanprogram med begränsade livslängdstjänster.

Följande kod används för att testa föregående mellanprogram:

using Middleware.Example;
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<IMessageWriter, LoggingMessageWriter>();

var app = builder.Build();

app.UseHttpsRedirection();

app.UseMyCustomMiddleware();

app.MapGet("/", () => "Hello World!");

app.Run();

Gränssnittet IMessageWriter och implementeringen:

namespace Middleware.Example;

public interface IMessageWriter
{
    void Write(string message);
}

public class LoggingMessageWriter : IMessageWriter
{

    private readonly ILogger<LoggingMessageWriter> _logger;

    public LoggingMessageWriter(ILogger<LoggingMessageWriter> logger) =>
        _logger = logger;

    public void Write(string message) =>
        _logger.LogInformation(message);
}

Ytterligare resurser

Exempelkod som används i den här artikeln
UseExtensions-källa på GitHub
Alternativ för livslängd och registrering innehåller ett fullständigt exempel på mellanprogram med begränsade, tillfälligaoch singleton- livslängdstjänster.
DJUPDYKNING: HUR BYGGER ASP.NET CORE MIDDLEWARE-PIPELINEN
ASP.NET Core Middleware
Testa ASP.NET Core-mellanprogram
Migrera HTTP-moduler till ASP.NET Core-mellanprogram
Start av applikation i ASP.NET Core
begär funktioner i ASP.NET Core
Fabriksbaserad aktivering av mellanprogram i ASP.NET Core
Mellanprogramsaktivering med en tredjepartscontainer i ASP.NET Core

Av Rick Anderson och Steve Smith

Anmärkning

Mellanprogramsklass

Mellanprogram kapslas vanligtvis in i en klass och exponeras med en tilläggsmetod. Överväg följande mellanprogram, som anger kulturen för den aktuella begäran från en frågesträng:

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        app.Use(async (context, next) =>
        {
            var cultureQuery = context.Request.Query["culture"];
            if (!string.IsNullOrWhiteSpace(cultureQuery))
            {
                var culture = new CultureInfo(cultureQuery);

                CultureInfo.CurrentCulture = culture;
                CultureInfo.CurrentUICulture = culture;
            }

            // Call the next delegate/middleware in the pipeline
            await next();
        });

        app.Run(async (context) =>
        {
            await context.Response.WriteAsync(
                $"Hello {CultureInfo.CurrentCulture.DisplayName}");
        });

    }
}

Föregående exempelkod används för att demonstrera skapandet av en mellanprogramskomponent. Information om ASP.NET Cores inbyggda lokaliseringsstöd finns i Globalisering och lokalisering i ASP.NET Core.

Testa mellanprogrammet genom att använda kulturparametern. Du kan till exempel begära https://localhost:5001/?culture=no.

Följande kod flyttar mellanprogramsdelegaten till en klass:

using Microsoft.AspNetCore.Http;
using System.Globalization;
using System.Threading.Tasks;

namespace Culture
{
    public class RequestCultureMiddleware
    {
        private readonly RequestDelegate _next;

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

        public async Task InvokeAsync(HttpContext context)
        {
            var cultureQuery = context.Request.Query["culture"];
            if (!string.IsNullOrWhiteSpace(cultureQuery))
            {
                var culture = new CultureInfo(cultureQuery);

                CultureInfo.CurrentCulture = culture;
                CultureInfo.CurrentUICulture = culture;

            }

            // Call the next delegate/middleware in the pipeline
            await _next(context);
        }
    }
}

Mellanprogramsklassen måste innehålla:

En offentlig konstruktor med en parameter av typen RequestDelegate.
En offentlig metod med namnet Invoke eller InvokeAsync. Den här metoden måste:
- Returnera en Task.
- Acceptera en första parameter av typen HttpContext.

Ytterligare parametrar för konstruktorn och Invoke/InvokeAsync fylls i av beroendeinmatning (DI).

Beroenden för mellanprogram

Mellanprogram bör följa principen explicita beroenden genom att exponera dess beroenden i konstruktorn. Mellanprogram konstrueras en gång per programlivslängd. Se avsnittet Beroenden för mellanprogram per begäran om du behöver dela tjänster med mellanprogram i en begäran.

Mellanprogramskomponenter kan lösa sina beroenden från beroendeinmatning (DI) via konstruktorparametrar. UseMiddleware kan också acceptera ytterligare parametrar direkt.

Beroenden för mellanprogramvara vid förfrågan

Eftersom mellanprogram skapas vid appstart delas inte begränsade livslängdstjänster som används av mellanprogramskonstruktorer med andra beroendeinmatade typer under varje begäran. Om du måste dela en begränsad tjänst mellan mellanprogram och andra typer lägger du till dessa tjänster i InvokeAsync metodens signatur. Metoden InvokeAsync kan acceptera ytterligare parametrar som fylls i av DI:

public class CustomMiddleware
{
    private readonly RequestDelegate _next;

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

    // IMyScopedService is injected into InvokeAsync
    public async Task InvokeAsync(HttpContext httpContext, IMyScopedService svc)
    {
        svc.MyProperty = 1000;
        await _next(httpContext);
    }
}

Alternativen för livslängd och registrering innehåller ett komplett urval av mellanprogram med begränsade livslängdstjänster.

Tilläggsmetod för mellanprogram

Följande tilläggsmetod exponerar mellanprogrammet via IApplicationBuilder:

using Microsoft.AspNetCore.Builder;

namespace Culture
{
    public static class RequestCultureMiddlewareExtensions
    {
        public static IApplicationBuilder UseRequestCulture(
            this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<RequestCultureMiddleware>();
        }
    }
}

Följande kod anropar mellanprogrammet från Startup.Configure:

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        app.UseRequestCulture();

        app.Run(async (context) =>
        {
            await context.Response.WriteAsync(
                $"Hello {CultureInfo.CurrentCulture.DisplayName}");
        });
    }
}

Ytterligare resurser

Alternativ för livslängd och registrering innehåller ett fullständigt exempel på mellanprogram med begränsade, tillfälligaoch singleton- livslängdstjänster.
ASP.NET Core Middleware
Testa ASP.NET Core-mellanprogram
Migrera HTTP-moduler till ASP.NET Core-mellanprogram
Start av applikation i ASP.NET Core
begär funktioner i ASP.NET Core
Fabriksbaserad aktivering av mellanprogram i ASP.NET Core
Mellanprogramsaktivering med en tredjepartscontainer i ASP.NET Core

Feedback

Var den här sidan till hjälp?

Dela via

Skriva anpassade ASP.NET Core-mellanprogram

Mellanprogramsklass

Beroenden för mellanprogram

Beroenden för mellanprogram per begäran

Ytterligare resurser

Mellanprogramsklass

Beroenden för mellanprogram

Beroenden för mellanprogramvara vid förfrågan

Tilläggsmetod för mellanprogram

Ytterligare resurser

Feedback

Ytterligare resurser