Middlewares en ASP.NET: pipeline y custom middleware
Clase 10 de 21 • Curso de APIs con .NET
Contenido del curso
Estructura de una Web API
- 7

Configuración CORS en .NET: solución al error
07:08 min - 8

Rutas en APIs .NET con parámetros
12:50 min - 9

Documentación de APIs con OpenAPI y Swagger en .NET
14:25 min - 10

Middlewares en ASP.NET: pipeline y custom middleware
Viendo ahora - 11

Inyección de dependencias en .NET: ILogger
09:18 min - 12

Middleware para autenticación básica en .NET
08:17 min
Arquitectura y Middlewares
- 13

Configuración de Entity Framework Core en .NET
07:31 min - 14

Modelos C# y relaciones con Entity Framework
10:01 min - 15

Servicios con Entity Framework para ASP.NET
13:51 min - 16

Controladores API en .NET con Swagger
14:46 min - 17

Conectar API .NET con SQL Server
09:51 min - 18

Conectar .NET API con PostgreSQL usando Entity Framework
06:57 min - 19

Qué es Clean Architecture en .NET
09:08 min - 20

Pruebas unitarias en .NET con Copilot
09:05 min - 21

Qué sigue después de tu API con .NET
02:16 min
Los middlewares en ASP.NET son clave para controlar cada paso de un request hasta la response. Aquí verás cómo funciona el pipeline, por qué el orden de ejecución importa y cómo crear un custom middleware para registrar rutas y códigos de estado, con una configuración limpia y mantenible.
¿Qué es un middleware y cómo opera el pipeline en ASP.NET?
Un middleware procesa el request desde que llega hasta que se envía la response. Cada componente ejecuta un fragmento de lógica (validación, transformación de datos, consultas) y luego llama al siguiente. Al finalizar, la respuesta recorre los mismos middlewares en sentido inverso.
- La secuencia completa se denomina tubería o pipeline.
- Puede devolver datos o errores, según la lógica aplicada.
- Incluye componentes como CORS, autenticación, autorización, custom middlewares y el middleware de endpoints.
Idea clave: el orden garantiza que la API procese correctamente la petición, valide accesos y ejecute la lógica del endpoint adecuado.
¿Dónde ordenar middlewares en program.cs y qué efectos tiene?
La configuración vive en el archivo program.cs, en la sección donde se agregan los middlewares en orden. Mantener ese orden asegura que el request se valide y rote correctamente hacia los endpoints.
- La ejecución de endpoints se produce con MapControllers.
- Cerca de UseAuthorization y MapControllers suelen ubicarse los custom middlewares para no romper la secuencia.
- Es recomendable no escribir middlewares anónimos extensos directamente en program.cs: mejor moverlos a clases dedicadas.
En la demostración, un middleware imprimió en consola el path del request y el status code de la response. Ejemplos observados:
- Ruta “/api/weatherforecast” devolviendo 200.
- Ruta “/api/weatherforecast/4” devolviendo 200.
- Ruta con parámetro inválido, devolviendo BadRequest.
¿Cómo crear un custom middleware y extender su uso?
Crear un middleware puede hacerse de forma inline con Use o moviéndolo a una clase propia para un mejor diseño. Ambos enfoques usan dos piezas: el context y el next.
¿Cómo usar Use con context y next?
Este patrón captura el path, invoca al siguiente middleware y luego lee el status code de la response.
app.Use(async (context, next) =>
{
Console.WriteLine($"Request: {context.Request.Path}");
await next();
Console.WriteLine($"Response: {context.Response.StatusCode}");
});
- context: contiene request, path, headers y cookies.
- next: invoca al siguiente componente del pipeline.
- Tras
await next(), ya puedes leer la response procesada.
¿Cómo moverlo a una clase RequestLoggingMiddleware?
Separar el código mejora la estructura y la mantenibilidad. La clase recibe un RequestDelegate en el constructor y expone InvokeAsync con el context.
public class RequestLoggingMiddleware
{
private readonly RequestDelegate _next;
public RequestLoggingMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
Console.WriteLine($"Request: {context.Request.Path}");
await _next(context);
Console.WriteLine($"Response: {context.Response.StatusCode}");
}
}
public static class RequestLoggingMiddlewareExtensions
{
public static IApplicationBuilder UseRequestLogging(this IApplicationBuilder app)
=> app.UseMiddleware<RequestLoggingMiddleware>();
}
Uso en program.cs, junto a otros componentes como UseCors, UseHttpsRedirection, UseAuthorization y MapControllers:
app.UseRequestLogging();
- Ubica la clase en una carpeta, por ejemplo: Middlewares/RequestLoggingMiddleware.cs.
- Agregar una extensión facilita invocarla de forma limpia y consistente.
¿Qué ejercicios ayudan a fortalecer el entendimiento?
- Mover UseCors al final, después de MapControllers, y probar con un cliente HTML o SPA: observa si aún funciona.
- Modificar el middleware para medir el tiempo total del request con un temporizador y registrar la duración.
- Usar middlewares para logging, añadir datos en encabezados, autenticación o manejo de excepciones.
¿Tienes dudas sobre el orden del pipeline o dónde colocar tu custom middleware? Comparte tu caso en comentarios y afinamos la configuración juntos.