C# Academy · Lección

Orden del middleware y middleware integrado

Comprenda el orden correcto del middleware para la autenticación, el enrutamiento, CORS y la gestión de excepciones.

Orden del middleware y middleware integrado es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Por qué es importante el orden

El middleware de ASP.NET Core se ejecuta exactamente en el orden en que se registra. Un orden incorrecto provoca vulnerabilidades de seguridad, problemas de rendimiento o comportamientos erróneos; por ejemplo, el enrutamiento debe ejecutarse antes que la autorización, y esta antes que la ejecución del endpoint.

Orden recomendado del middleware

Microsoft documenta el orden recomendado. Apartarse de él provoca problemas difíciles de depurar. Este es el orden canónico para una API de ASP.NET Core en producción.

// Recommended order:
app.UseExceptionHandler();    // 1. Catch all exceptions
app.UseHsts();                // 2. HTTP Strict Transport Security
app.UseHttpsRedirection();    // 3. Redirect HTTP to HTTPS
app.UseStaticFiles();         // 4. Serve static assets
app.UseRouting();             // 5. Match route patterns
app.UseCors();                // 6. Cross-Origin
app.UseAuthentication();      // 7. Who are you?
app.UseAuthorization();       // 8. Are you allowed?
app.UseRateLimiter();         // 9. Throttle
app.UseOutputCache();         // 10. Cache responses
// Map endpoints here
app.MapControllers();
app.Run();

Gestión de excepciones en primer lugar

El middleware de gestión de excepciones debe ser el primero, en la posición más externa, para capturar las excepciones de todos los componentes de middleware y endpoints posteriores.

// Development: detailed error page
if (app.Environment.IsDevelopment())
    app.UseDeveloperExceptionPage();
else
{
    // Production: generic error page + structured response
    app.UseExceptionHandler("/error");
    app.UseHsts();
}

// OR: use ProblemDetails globally (recommended .NET 8+)
builder.Services.AddProblemDetails();
app.UseExceptionHandler();
// All unhandled exceptions -> RFC 7807 ProblemDetails JSON

Archivos estáticos antes del enrutamiento

Los archivos estáticos (UseStaticFiles) deben ir antes del enrutamiento. Servir un archivo estático interrumpe el pipeline, por lo que no es necesario ejecutar la autenticación ni el enrutamiento para /css/main.css.

app.UseStaticFiles(); // serves wwwroot/* without going through auth
app.UseRouting();     // expensive: runs route matching

// If you put UseStaticFiles AFTER UseRouting, the route
// matcher runs unnecessarily for every .js/.css request.
// Serve static files first for better performance.

Autenticación antes de autorización

UseAuthentication debe ejecutarse antes que UseAuthorization. La autenticación rellena HttpContext.User; la autorización comprueba ese usuario ya rellenado frente a las políticas.

// WRONG ORDER — authorization runs before user is populated:
app.UseAuthorization();  // user is null → everything allowed!
app.UseAuthentication(); // too late

// CORRECT:
app.UseAuthentication(); // populates context.User
app.UseAuthorization();  // checks context.User against policies

CORS antes de la autenticación

El middleware de CORS debe ejecutarse antes de la autenticación para que las solicitudes OPTIONS de preflight se gestionen sin requerir encabezados de autenticación.

builder.Services.AddCors(opts =>
    opts.AddPolicy("Frontend", p =>
        p.WithOrigins("https://myapp.com")
         .AllowAnyHeader()
         .AllowAnyMethod()));

app.UseRouting();
app.UseCors("Frontend"); // before auth — handles OPTIONS pre-flight
app.UseAuthentication();
app.UseAuthorization();

Middleware integrado habitual

ASP.NET Core incluye muchos componentes de middleware integrados. Saber qué hace cada uno le ayuda a comprender cuándo y cómo utilizarlos.

// Compression: compresses responses (must be before static files)
builder.Services.AddResponseCompression();
app.UseResponseCompression();

// Request localization: sets culture from Accept-Language header
builder.Services.AddLocalization();
app.UseRequestLocalization();

// Health checks: /health endpoint
builder.Services.AddHealthChecks();
app.MapHealthChecks("/health");

// Forwarded headers: trust X-Forwarded-For from reverse proxy
app.UseForwardedHeaders();

Análisis detallado del middleware de enrutamiento

UseRouting() hace coincidir la solicitud entrante con un patrón de ruta y almacena la coincidencia en HttpContext. A continuación, UseEndpoints() (o MapXxx()) ejecuta el endpoint coincidente.

app.UseRouting(); // matches route, stores in context

// Between UseRouting and Map*: middleware can read route data
app.Use(async (ctx, next) =>
{
    var endpoint = ctx.GetEndpoint();
    var routeName = endpoint?.DisplayName;
    Console.WriteLine($"Matched: {routeName}");
    await next(ctx);
});

// All auth and other middleware go here
app.UseAuthentication();
app.UseAuthorization();

// Execute the matched endpoint
app.MapControllers();
app.MapGet("/", () => "Home");

Ubicación de la compresión de respuestas

La compresión de respuestas debe ejecutarse antes de los archivos estáticos y del enrutamiento para que la salida comprimida se escriba antes de generar el contenido. Colóquela inmediatamente después del manejo de excepciones.

// Correct placement for response compression:
app.UseExceptionHandler();
app.UseResponseCompression(); // before static files
app.UseStaticFiles();          // compressed static files
app.UseRouting();
// ... rest of pipeline

Caso real: canalización completa de producción

Una canalización de producción completa que combina todas las recomendaciones en una pila de middleware segura y ordenada correctamente.

var app = builder.Build();

if (app.Environment.IsDevelopment())
    app.UseDeveloperExceptionPage();
else { app.UseExceptionHandler(); app.UseHsts(); }

app.UseResponseCompression();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseCors("AllowFrontend");
app.UseAuthentication();
app.UseAuthorization();
app.UseRateLimiter();
app.UseOutputCache();

app.MapHealthChecks("/health").AllowAnonymous();
app.MapControllers();

app.Run();

Comprobación rápida

¿Por qué debe ejecutarse UseAuthentication antes que UseAuthorization en la canalización de middleware?

Resumen: orden del middleware y middleware integrado

Aspectos clave:

El manejo de excepciones primero, los archivos estáticos antes del enrutamiento, la autenticación antes de la autorización y CORS antes de la autenticación
La compresión de respuestas se ejecuta pronto (antes de los archivos estáticos) para lograr el máximo efecto
UseRouting + UseAuthorization + Map* — el middleware situado entre ellos puede leer los datos de la ruta
Integrados: UseHsts, UseHttpsRedirection, UseStaticFiles, UseRateLimiter, UseOutputCache
Compruebe ctx.GetEndpoint() entre UseRouting y MapXxx para leer la información de la ruta coincidente

Preguntas frecuentes

¿La lección «Orden del middleware y middleware integrado» es gratis?

Sí — el texto completo de «Orden del middleware y middleware integrado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Orden del middleware y middleware integrado»?

Comprenda el orden correcto del middleware para la autenticación, el enrutamiento, CORS y la gestión de excepciones. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Orden del middleware y middleware integrado»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Descripción general de la canalización de ASP.NET Core
Escritura de middleware personalizado
Cortocircuito y ramificación
Orden del middleware y middleware integrado

← Volver a C# Academy