C# Academy · Lektion

Oversigt over ASP.NET Core-pipelinen

Forstå, hvordan anmodninger bevæger sig gennem middleware-pipelinen og HttpContext, og hvordan svar bygges op.

Lektion 1 af 412 trin

Oversigt over ASP.NET Core-pipelinen er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i C# Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C# Academy-kurset indeholder 4 lektioner i alt.

Anmodningskæden

Alle HTTP-anmodninger i ASP.NET Core går gennem en middleware-kæde. Hvert stykke middleware kan inspicere, ændre, afkorte eller videresende anmodningen til den næste komponent. Det er grundlæggende at forstå denne kæde, når du bygger ASP.NET Core-apps.

HttpContext: Anmodningens indpakning

HttpContext indeholder alt om en anmodning og et svar: headere, cookies, brødtekst, brugerens claims, forbindelsesoplysninger og annulleringstokenet. Al middleware arbejder med den.

app.Use(async (context, next) =>
{
    // Read request info
    var method  = context.Request.Method;
    var path    = context.Request.Path;
    var headers = context.Request.Headers;
    var user    = context.User.Identity?.Name;

    // Write to response
    context.Response.Headers.Append("X-Processed-By", "MyMiddleware");

    await next(context); // forward to next middleware
});

Rækkefølgen ved registrering af middleware

Middleware kører i den rækkefølge, den registreres i. Svaret pakkes ud i omvendt rækkefølge, ligesom en stak. Rækkefølgen er afgørende: godkendelse skal køre før autorisation, og routing før matchning af endpoints.

// Typical order for an ASP.NET Core app:
app.UseExceptionHandler("/error"); // outermost — catches everything
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseCors("policy");
app.UseAuthentication();  // must be before Authorization
app.UseAuthorization();
app.UseRateLimiter();
app.UseOutputCache();
// MapHub, MapControllers, MapGet etc.
app.Run();

Use, Run og Map

Tre metoder tilføjer middleware: Use kalder den næste, Run afslutter kæden og kalder aldrig den næste, og Map forgrener baseret på stien.

// Use: passes to next
app.Use(async (ctx, next) =>
{
    Console.WriteLine("Before");
    await next(ctx);
    Console.WriteLine("After");
});

// Run: terminal — no next
app.Run(async ctx =>
    await ctx.Response.WriteAsync("Terminal"));

// Map: branch on path prefix
app.Map("/api", apiApp =>
    apiApp.Run(async ctx =>
        await ctx.Response.WriteAsync("API branch")));

Anmodnings- og svarbrødtekster

Anmodnings- og svarbrødtekster er streams. Anmodningsbrødteksten kan kun læses én gang — aktivér buffering af anmodningsbrødteksten, hvis du har brug for at læse den flere gange, f.eks. i flere stykker middleware.

app.Use(async (ctx, next) =>
{
    // Enable buffering so body can be read multiple times
    ctx.Request.EnableBuffering();

    using var reader = new StreamReader(
        ctx.Request.Body,
        leaveOpen: true);
    var body = await reader.ReadToEndAsync();
    ctx.Request.Body.Position = 0; // rewind for next middleware

    Console.WriteLine($"Body: {body}");
    await next(ctx);
});

Afkortning af anmodningskæden

Middleware kan afkorte kæden ved at skrive svaret og IKKE kalde next. Det er nyttigt til adgangskontrol, sundhedstjek eller vedligeholdelsessider.

app.Use(async (ctx, next) =>
{
    if (ctx.Request.Path == "/maintenance")
    {
        ctx.Response.StatusCode = 503;
        await ctx.Response.WriteAsync("Service under maintenance");
        return; // short-circuit — next is NOT called
    }
    await next(ctx);
});

IMiddleware-interfacet

Hvis du har brug for klassebaseret middleware med DI, skal du implementere IMiddleware. Registrér implementeringen i DI, og brug app.UseMiddleware<T>().

public class RequestTimingMiddleware : IMiddleware
{
    private readonly ILogger<RequestTimingMiddleware> _logger;
    public RequestTimingMiddleware(ILogger<RequestTimingMiddleware> l) => _logger = l;

    public async Task InvokeAsync(HttpContext ctx, RequestDelegate next)
    {
        var sw = System.Diagnostics.Stopwatch.StartNew();
        await next(ctx);
        _logger.LogInformation("{Method} {Path}: {Ms}ms",
            ctx.Request.Method, ctx.Request.Path, sw.ElapsedMilliseconds);
    }
}

// Register:
builder.Services.AddTransient<RequestTimingMiddleware>();
app.UseMiddleware<RequestTimingMiddleware>();

Middleware-klasser efter konvention

Du kan også oprette en klasse med en InvokeAsync(HttpContext, RequestDelegate)-metode. Frameworket indsprøjter afhængigheder, herunder den næste delegate, via konstruktøren.

public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _key;

    // RequestDelegate injected by framework
    public ApiKeyMiddleware(RequestDelegate next, IConfiguration cfg)
    {
        _next = next;
        _key = cfg["ApiKey"] ?? "";
    }

    public async Task InvokeAsync(HttpContext ctx)
    {
        if (ctx.Request.Headers["X-Api-Key"] != _key)
        {
            ctx.Response.StatusCode = 401;
            return;
        }
        await _next(ctx);
    }
}

Ændring af svar efter next

Kode efter await next(ctx) kører, efter at svaret er begyndt at blive skrevet. Du kan tilføje svarheadere før next, men du kan ikke ændre statuskoden eller brødteksten bagefter.

app.Use(async (ctx, next) =>
{
    // Before: add response headers (safe)
    ctx.Response.OnStarting(() =>
    {
        ctx.Response.Headers.Append("X-Request-Id",
            Guid.NewGuid().ToString("N"));
        return Task.CompletedTask;
    });

    await next(ctx);

    // After: response may already be sent
    // SAFE: logging, metrics
    // UNSAFE: changing status code or writing body
    Console.WriteLine($"Response status: {ctx.Response.StatusCode}");
});

I praksis: Middleware til korrelations-ID

Middleware til korrelations-ID fra produktion, som tilføjer et sporings-ID til hver anmodning for distribueret sporing og logning.

public class CorrelationIdMiddleware
{
    private readonly RequestDelegate _next;
    private const string Header = "X-Correlation-Id";

    public CorrelationIdMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext ctx)
    {
        var correlationId = ctx.Request.Headers[Header].FirstOrDefault()
            ?? Guid.NewGuid().ToString("N");

        ctx.Items["CorrelationId"] = correlationId;

        ctx.Response.OnStarting(() =>
        {
            ctx.Response.Headers.Append(Header, correlationId);
            return Task.CompletedTask;
        });

        using (Serilog.Context.LogContext.PushProperty("CorrelationId", correlationId))
            await _next(ctx);
    }
}

Hurtigt tjek

Hvad er forskellen på app.Use() og app.Run(), når du tilføjer middleware?

Besvar den i den interaktive lektion

Opsummering: Overblik over ASP.NET Core-anmodningskæden

Vigtigste pointer:

Middleware kører i registreringsrækkefølge; svar afvikles i omvendt rækkefølge
Use → kalder den næste; Run → afslutter kæden; Map → forgrener baseret på sti
HttpContext indeholder anmodning, svar, bruger og annulleringstoken
Aktivér buffering for at kunne læse anmodningsbrødteksten flere gange
IMiddleware-interfacet muliggør klassebaseret middleware, der fungerer godt med DI
Tilføj svarheadere via OnStarting(); ændr ikke status efter next

Gratis at komme i gang

Lær C# med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 93
Lektioner: 346

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Oversigt over ASP.NET Core-pipelinen” gratis?

Ja — hele teksten til “Oversigt over ASP.NET Core-pipelinen” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af C# Academy-kurset, skal du opgradere til CoddyKit PRO. C# Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Oversigt over ASP.NET Core-pipelinen”?

Forstå, hvordan anmodninger bevæger sig gennem middleware-pipelinen og HttpContext, og hvordan svar bygges op. Du øver dig i C# Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C# Academy?

Der kræves ingen tidligere erfaring. C# Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Oversigt over ASP.NET Core-pipelinen”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C# Academy-lektion?

Ja. Alle C# Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Oversigt over ASP.NET Core-pipelinen
Skriv brugerdefineret middleware
Kortslutning og forgrening
Middleware-rækkefølge og indbygget middleware

← Tilbage til C# Academy