202g-11-09T00:16

Inleiding

De ASP.NET Core aanvraag en response pipeline is de ruggengraat van elke webapplicatie die op dit framework is gebouwd.

Begrijpen hoe een verzoek door uw applicatie stroomt en hoe antwoorden worden gegenereerd is cruciaal voor het bouwen van efficiënte, onderhoudbare en veilige webapplicaties.

Deze serie zal u door elke laag van de pijplijn leiden, vanaf het moment dat een HTTP-verzoek op uw server aankomt tot wanneer het antwoord naar de client wordt teruggestuurd.

Of je nu API's, webapplicaties of microservices bouwt, de pijpleiding is er altijd, werken achter de schermen.

Door het diep te begrijpen, zult u in staat zijn om prestaties te optimaliseren, cross-cutting zorgen elegant te implementeren, en problemen effectiever oplossen.

OPMERKING: Dit is onderdeel van mijn experimenten met AI / een manier om $1000 Calude Code Web credits te besteden.**Ik heb dit een BUNCH van papieren gevoerd, mijn begrip, vragen die ik moest genereren van dit artikel.**Het is leuk en vult een gat dat ik nergens anders heb gezien.

1. **Wat is de Request Pipeline?**In de kern is de ASP.NET Core request pipeline een reeks componenten die HTTP-verzoeken verwerken en HTTP-antwoorden genereren.
2. **Zie het als een transportband in een fabriek: het verzoek komt aan de ene kant binnen, gaat door verschillende stations (componenten) die het onderzoeken, wijzigen, of handelen, en uiteindelijk een reactie ontstaat aan de andere kant.**Deze architectuur is gebaseerd op de
3. middleware patroon, waarbij elk onderdeel (middleware) een specifieke verantwoordelijkheid heeft en:

Bezig met verwerken van het binnenkomende verzoek

alvorens het door te geven aan het volgende onderdeel

flowchart TB
    OS[Operating System and Network TCP IP Socket Layer]
    Kestrel[Kestrel Web Server HTTP11 HTTP2 HTTP3 QUIC TLS SSL Termination Connection Management]
    Host[Host Layer Application Lifetime Dependency Injection Configuration Logging]

    subgraph Middleware_Pipeline [Middleware Pipeline]
        EH[Exception Handler Middleware catches exceptions]
        HTTPS[HTTPS Redirection Middleware redirects HTTP to HTTPS]
        Static[Static Files Middleware serves static content]
        Routing[Routing Middleware matches request to endpoint]
        AuthN[Authentication Middleware validates identity]
        AuthZ[Authorization Middleware validates permissions]
        Custom[Custom Middleware app specific logic]
        EndpointMW[Endpoint Middleware executes matched endpoint]
    end

    EndpointExec[Endpoint Execution MVC Controllers and Actions Razor Pages Minimal APIs gRPC SignalR]
    Response[Response Generation flows back through middleware]
    BackKestrel[Back to Kestrel]
    Client[Back to Client]

    OS --> Kestrel --> Host --> EH --> HTTPS --> Static --> Routing --> AuthN --> AuthZ --> Custom --> EndpointMW --> EndpointExec --> Response --> BackKestrel --> Client

Kortsluiting van de pijpleiding

door onmiddellijk een reactie te genereren

Bezig met het verwerken van het uitgaande antwoord

nadat het volgende onderdeel is uitgevoerd

De architectuur op hoog niveau

Laten we de complete pijplijn architectuur in ASP.NET Core 8 visualiseren:

• Vraag stroom: Een reis door de Pipeline
• Laten we een typisch HTTP-verzoek volgen als het door de pijpleiding reist:
• 1.HttpContextNetwerklaag
• Wanneer een client een verzoek doet naar uw applicatie, komt het als rauwe TCP/IP pakketten op uw server.

De netwerkstapel van het besturingssysteem assembleert deze pakketten in een compleet HTTP-verzoek.

• Kestrel Web Server
• Kestrel, ASP.NET Core's cross-platform webserver, ontvangt het verzoek.
• Kestrel:
• Ontleedt het HTTP-protocol (HTTP/1.1, HTTP/2 of HTTP/3)

Behandelt TLS/SSL-decryptie als HTTPS wordt gebruikt

Maakt een

• object dat zowel het verzoek als het antwoord vertegenwoordigtHttpContext
• Geeft controle door aan de middleware pijpleiding van de applicatie
• Hostlaag
• De host biedt de uitvoering omgeving.

Het:

Beheert de levensduur van de applicatie

• Biedt de afhankelijkheidsinjectie container
• Levert configuratie- en loginfrastructuur
• Roept de middleware pijpleiding op
• Middleware Pipeline

Hier begint je toepassingslogica.

Elke middleware component:

Ontvangt de

• Voert zijn specifieke functie uit
• Bepaalt of de volgende middleware of short-circuit wordt gebeld
• Kan het verzoek wijzigen alvorens door te geven
• Kan het antwoord wijzigen nadat het terug is

5.

sequenceDiagram
    autonumber
    participant Client
    participant OS as OS/Network
    participant Kestrel
    participant Host
    participant MW as Middleware Pipeline
    participant Endpoint as Endpoint Execution

    Client->>OS: HTTP request
    OS->>Kestrel: Forward request
    Kestrel->>Host: Create HttpContext
    Host->>MW: Invoke pipeline
    MW->>Endpoint: Route matched, execute
    Endpoint-->>MW: Response
    MW-->>Kestrel: Response after post-processing
    Kestrel-->>OS: Send HTTP response
    OS-->>Client: Response delivered

Eindpuntuitvoering

Als het verzoek het door alle middleware haalt, bereikt het een eindpunt:

Een controller actie in MVCHttpContextEen paginaverwerker in Razor Pages

public abstract class HttpContext
{
    // The incoming request
    public abstract HttpRequest Request { get; }

    // The outgoing response
    public abstract HttpResponse Response { get; }

    // User identity and authentication
    public abstract ClaimsPrincipal User { get; set; }

    // Request-scoped services
    public abstract IServiceProvider RequestServices { get; set; }

    // Connection information
    public abstract ConnectionInfo Connection { get; }

    // WebSocket support
    public abstract WebSocketManager WebSockets { get; }

    // Request cancellation
    public abstract CancellationToken RequestAborted { get; set; }

    // Session state
    public abstract ISession Session { get; }

    // Generic feature collection
    public abstract IFeatureCollection Features { get; }

    // And more...
}

Een route begeleider in Minimal API'sHttpContext.

Een gRPC-servicemethode

Een SignalR-hubmethode

// Basic middleware signature
public delegate Task RequestDelegate(HttpContext context);

// Middleware can be implemented as a method
app.Use(async (context, next) =>
{
    // Do something before the next middleware
    Console.WriteLine($"Request: {context.Request.Path}");

    // Call the next middleware
    await next(context);

    // Do something after the next middleware
    Console.WriteLine($"Response: {context.Response.StatusCode}");
});

Het eindpunt voert uw bedrijfslogica uit en genereert een reactie.

public delegate Task RequestDelegate(HttpContext context);

Responsstroom

De respons stroomt terug door de middleware pijpleiding in omgekeerde:

Elke middleware kan het antwoord inspecteren of wijzigen

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

// Middleware 1: Logging
app.Use(async (context, next) =>
{
    Console.WriteLine($"[{DateTime.UtcNow:yyyy-MM-dd HH:mm:ss}] Request started: {context.Request.Method} {context.Request.Path}");

    await next(context);

    Console.WriteLine($"[{DateTime.UtcNow:yyyy-MM-dd HH:mm:ss}] Request finished: {context.Response.StatusCode}");
});

// Middleware 2: Custom header
app.Use(async (context, next) =>
{
    context.Response.Headers["X-Custom-Header"] = "Hello from middleware!";

    await next(context);
});

// Middleware 3: Short-circuit for specific path
app.Use(async (context, next) =>
{
    if (context.Request.Path == "/health")
    {
        context.Response.StatusCode = 200;
        await context.Response.WriteAsync("Healthy");
        return; // Short-circuit - don't call next()
    }

    await next(context);
});

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

app.Run();

Kopteksten zijn voltooidhttp://localhost:5000/Het antwoordorgaan is geschreven

Console output:
[2024-01-15 10:30:45] Request started: GET /
[2024-01-15 10:30:45] Request finished: 200

Browser output:
Hello World!

Response headers:
X-Custom-Header: Hello from middleware!

Kestrel stuurt het HTTP antwoord terug naar de clienthttp://localhost:5000/health:

Console output:
[2024-01-15 10:30:50] Request started: GET /health
[2024-01-15 10:30:50] Request finished: 200

Browser output:
Healthy

Response headers:
X-Custom-Header: Hello from middleware!

Sequentiediagram aanvragen/antwoorden/healthSleutelbegrippen

HttpContext

De

1. **is het centrale object in de pijplijn.**Het omvat:

2. Alles wat je moet weten over het huidige verzoek en alles wat je nodig hebt om het antwoord te bouwen is toegankelijk viaMiddleware

3. **Middleware is de bouwsteen van de pijpleiding.**Op zijn eenvoudigste, middleware is een functie die een verzoek verwerkt:

4. Verzoek om gedelegeerdenEen verzoekdelegatie is een functie die een HTTP-verzoek kan verwerken.

5. **De hele middleware pijplijn is opgebouwd uit een keten van verzoekafgevaardigden:**Elke middleware wraps de volgende gedelegeerde, het creëren van een geneste keten van oproepen.

Een eenvoudig voorbeeld

Laten we eens kijken naar een minimale ASP.NET Core 8 applicatie die de pijplijn toont:

Wanneer u bezoekt

• **, zul je zien:**Wanneer u bezoekt

• Merk op hoe de derde middleware kortsluiting van de pijpleiding voor depad, maar alle middleware voordat het nog steeds uitgevoerd.

• Waarom begrijpen van de Pipeline-aangelegenhedenHet begrijpen van de pijpleiding is cruciaal omdat:

• Optimalisatie van de prestaties: Het kennen van de volgorde van uitvoering helpt u dure operaties op de juiste manier te plaatsen en onnodig werk te vermijden.

• Cross-cutting Concerns: Middleware is perfect voor het implementeren van logging, authenticatie, foutafhandeling, en andere zorgen die van invloed zijn op alle verzoeken.IStartupFilter, IHostedServiceDebuggen

: Als er iets misgaat, helpt het begrijpen van de pijplijn je te achterhalen waar het probleem zich heeft voorgedaan.

• Aangepaste extensies
• : U kunt krachtige aangepaste middleware maken om de mogelijkheden van het framework uit te breiden.
• HttpContextVeiligheid
• : Begrijpen hoe authenticatie en autorisatie passen in de pijplijn is essentieel voor het beveiligen van uw toepassing.
• Wat is het volgende?

In dit eerste deel hebben we de basis gelegd door te begrijpen wat de pijpleiding is, hoe het gestructureerd is en hoe verzoeken er doorheen stromen.