202g-11-09T00:16

Introducción

El conducto de petición y respuesta ASP.NET Core es la columna vertebral de todas las aplicaciones web construidas sobre este marco.

Comprender cómo fluye una solicitud a través de su aplicación y cómo se generan las respuestas es crucial para construir aplicaciones web eficientes, mantenibles y seguras.

Esta serie le guiará a través de cada capa de la tubería, desde el momento en que una solicitud HTTP llega a su servidor hasta cuando la respuesta es enviada al cliente.

Ya sea que esté construyendo APIs, aplicaciones web o microservicios, la tubería siempre está ahí, trabajando entre bastidores.

Al comprenderlo profundamente, podrás optimizar el rendimiento, implementar preocupaciones transversales de manera elegante y solucionar problemas de manera más eficaz.

NOTA: Esto es parte de mis experimentos con IA / una manera de gastar $1000 Créditos Web Código Calude.**He alimentado esto un montón de papeles, mi comprensión, preguntas que tuve que generar este artículo.**Es divertido y llena un hueco que no he visto en ningún otro lugar.

1. **¿Qué es el Pipeline de Solicitud?**En esencia, el conducto de solicitud de ASP.NET Core es una serie de componentes que procesan las solicitudes HTTP y generan respuestas HTTP.
2. **Piense en ello como una cinta transportadora en una fábrica: la solicitud entra en un extremo, pasa a través de varias estaciones (componentes) que la examinan, modifican o actúan sobre ella, y finalmente surge una respuesta en el otro extremo.**Esta arquitectura se basa en el
3. patrón middleware, cuando cada componente (middleware) tenga una responsabilidad específica y pueda:

Procesar la solicitud entrante

antes de pasarlo al siguiente componente

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

El cortocircuito de la tubería

generando una respuesta inmediatamente

Procesar la respuesta saliente

después de que el siguiente componente se haya ejecutado

La arquitectura de alto nivel

Vamos a visualizar la arquitectura de tuberías completa en ASP.NET Core 8:

• Request Flow: Un viaje a través del oleoducto
• Sigamos una petición HTTP típica mientras viaja a través de la tubería:
• 1.HttpContextCapa de red
• Cuando un cliente hace una solicitud a su aplicación, llega como paquetes TCP/IP en bruto a su servidor.

La pila de red del sistema operativo ensambla estos paquetes en una petición HTTP completa.

• Servidor web de Kestrel
• Kestrel, el servidor web multiplataforma de ASP.NET Core, recibe la solicitud.
• Kestrel:
• Analiza el protocolo HTTP (HTTP/1.1, HTTP/2 o HTTP/3)

Manipula el descifrado TLS/SSL si se utiliza HTTPS

Crea un

• objeto que representa tanto la petición como la respuestaHttpContext
• Pasa el control a la tubería de middleware de la aplicación
• Capa de host
• El host proporciona el entorno de ejecución.

Lo siguiente:

Administra la vida útil de la aplicación

• Proporciona el envase de inyección de dependencia
• Infraestructura de configuración y registro de suministros
• Invoca la tubería de middleware
• Pipeline de Middleware

Aquí es donde comienza tu lógica de aplicación.

Cada componente de middleware:

Recibe la

• Desempeña su función específica
• Decide si llamar al siguiente middleware o cortocircuito
• Puede modificar la solicitud antes de pasarla hacia adelante
• Puede modificar la respuesta después de que vuelva

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

Ejecución del punto final

Si la solicitud lo hace a través de todo middleware, llega a un punto final:

Una acción controladora en MVCHttpContextUn manejador de páginas en páginas Razor

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...
}

Un manejador de rutas en APIs MínimasHttpContext.

Un método de servicio gRPC

Un método de hub de SignalR

// 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}");
});

El punto final ejecuta la lógica de su negocio y genera una respuesta.

public delegate Task RequestDelegate(HttpContext context);

Flujo de respuesta

La respuesta fluye de nuevo a través de la tubería de middleware en reversa:

Cada middleware puede inspeccionar o modificar la respuesta

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();

Finalización de las cabecerashttp://localhost:5000/El cuerpo de respuesta está escrito

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 envía la respuesta HTTP al clientehttp://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!

Request/Response Sequence Diagram/healthConceptos clave

HttpContext

Los

1. **es el objeto central en la tubería.**Encapsula:

2. Todo lo que necesita saber sobre la solicitud actual y todo lo que necesita para construir la respuesta es accesible a través deMiddleware

3. **Middleware es el bloque de construcción de la tubería.**En su más simple, middleware es una función que procesa una petición:

4. Solicitud DelegadasUn delegado de solicitud es una función que puede procesar una solicitud HTTP.

5. **Toda la tubería de middleware se construye a partir de una cadena de delegados de petición:**Cada middleware envuelve al siguiente delegado, creando una cadena anidada de llamadas.

Un ejemplo sencillo

Veamos una aplicación mínima ASP.NET Core 8 que demuestra la tubería:

Cuando usted visita

• **, ya verás:**Cuando usted visita

• Observe cómo el tercer middleware cortocircuito la tubería para elruta, pero todo el middleware antes de que todavía se ejecuta.

• Por qué es importante entender el oleoductoComprender la tubería es crucial porque:

• Optimización del rendimiento: Conocer el orden de ejecución le ayuda a colocar operaciones costosas adecuadamente y evitar trabajos innecesarios.

• Preocupaciones cruzadas: Middleware es perfecto para implementar registro, autenticación, manejo de errores y otras preocupaciones que afectan a todas las solicitudes.IStartupFilter, IHostedServiceDepuración

: Cuando algo sale mal, entender la tubería le ayuda a identificar dónde ocurrió el problema.

• Extensiones personalizadas
• : Puede crear potente middleware personalizado para ampliar las capacidades del framework.
• HttpContextSeguridad
• : Comprender cómo la autenticación y la autorización encajan en la tubería es esencial para asegurar su aplicación.
• ¿Qué sigue?

En esta primera parte, hemos establecido la base mediante la comprensión de lo que es el gasoducto, cómo está estructurado, y cómo las peticiones fluyen a través de él.