Cortocircuito y ramificación
Use MapWhen, UseWhen y middleware terminal para ramificar o finalizar la canalización según las condiciones de la solicitud.
Cortocircuito y ramificación es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 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.
Bifurcaciones e interrupciones
No todas las solicitudes deben recorrer el pipeline de middleware completo. ASP.NET Core proporciona herramientas para bifurcar el pipeline, dirigiendo subconjuntos a distintos pipelines, y para interrumpirlo, deteniendo el procesamiento y devolviendo la respuesta de inmediato.
Map: bifurcación permanente por ruta
Map crea una bifurcación permanente: las solicitudes que coinciden con el prefijo entran en la bifurcación y NUNCA vuelven al pipeline principal.
app.Map("/api", apiApp =>
{
apiApp.UseAuthentication();
apiApp.UseAuthorization();
apiApp.Run(async ctx =>
await ctx.Response.WriteAsync("API branch"));
});
// Requests to /api/... enter the branch above.
// Requests to /public/... skip the branch entirely.
app.Run(async ctx =>
await ctx.Response.WriteAsync("Main pipeline"));MapWhen: bifurcación mediante un predicado
MapWhen crea una bifurcación según cualquier condición, como encabezados, parámetros de consulta o lógica personalizada. Al igual que Map, la bifurcación es permanente y no vuelve a unirse al pipeline principal.
// Branch when a specific header is present
app.MapWhen(
ctx => ctx.Request.Headers.ContainsKey("X-Internal"),
internalApp =>
{
internalApp.UseMiddleware<InternalApiMiddleware>();
internalApp.Run(async ctx =>
await ctx.Response.WriteAsync("Internal route"));
});
// Branch on query parameter
app.MapWhen(
ctx => ctx.Request.Query.ContainsKey("legacy"),
legacyApp => legacyApp.UseMiddleware<LegacyHandlerMiddleware>());UseWhen: bifurcación condicional que vuelve a unirse
UseWhen es similar a MapWhen, pero la bifurcación vuelve a unirse al pipeline principal cuando termina. Esto permite agregar middleware de forma condicional sin crear una bifurcación permanente.
// Log only for authenticated API calls; public routes not logged
app.UseWhen(
ctx => ctx.Request.Path.StartsWithSegments("/api")
&& ctx.User.Identity?.IsAuthenticated == true,
loggedApp =>
{
loggedApp.UseMiddleware<AuditMiddleware>();
});
// All requests continue here after the branch
app.UseRouting();
app.MapControllers();Interrupción al no llamar a Next
Cualquier middleware puede interrumpir el pipeline escribiendo la respuesta y no llamando a next. El pipeline se detiene en ese punto y la respuesta se devuelve al cliente.
app.Use(async (ctx, next) =>
{
// IP allowlist check
var ip = ctx.Connection.RemoteIpAddress?.ToString();
var allowed = new[] { "127.0.0.1", "::1", "10.0.0.0/8" };
if (!IsAllowed(ip, allowed))
{
ctx.Response.StatusCode = 403;
await ctx.Response.WriteAsJsonAsync(
new { error = "Access denied from this IP" });
return; // short-circuit
}
await next(ctx); // proceed
});ShortCircuit() en .NET 8
En .NET 8, MapShortCircuit y la extensión ShortCircuit() en los endpoints proporcionan una ruta declarativa y altamente optimizada para interrumpir el pipeline.
// Reject known bad paths immediately — skip entire pipeline
app.MapShortCircuit(404, "robots.txt", "favicon.ico");
// Or on a specific endpoint:
app.MapGet("/health", () => "OK")
.ShortCircuit(); // skips auth, rate limiting, etc.
// 'Run' middleware also short-circuits:
app.Map("/old-api", old =>
old.Run(ctx =>
{
ctx.Response.StatusCode = 301;
ctx.Response.Headers.Location = "/api/v2";
return Task.CompletedTask;
}));Middleware terminal frente al enrutamiento de endpoints
Antes de .NET 3, app.Run() era la única opción terminal. Ahora se prefiere el enrutamiento de endpoints (MapGet, MapControllers), ya que participa en la autorización, la limitación de velocidad y los metadatos.
// OLD: terminal middleware
app.Run(async ctx => {
if (ctx.Request.Path == "/ping")
await ctx.Response.WriteAsync("pong");
});
// PREFERRED: endpoint routing
app.MapGet("/ping", () => "pong")
.WithTags("Health")
.AllowAnonymous()
.RequireRateLimiting("basic");Matices de la coincidencia de rutas
Map("/api") coincide con /api y /api/anything. La ruta coincidente se elimina de Request.Path dentro de la bifurcación y se coloca en Request.PathBase.
app.Map("/api", apiApp =>
{
apiApp.Use(async (ctx, next) =>
{
// Path in branch: /users/42 (prefix removed)
Console.WriteLine(ctx.Request.Path); // /users/42
Console.WriteLine(ctx.Request.PathBase); // /api
await next(ctx);
});
apiApp.MapGet("/users/{id}", (int id) => id);
});Combinación de patrones de bifurcación
Las aplicaciones reales combinan Map, UseWhen e interrupciones para crear pipelines por capas: las rutas públicas son ligeras, las rutas de API incluyen autenticación y las rutas de administración tienen comprobaciones adicionales.
// Public area — no auth
app.Map("/public", pub =>
{
pub.MapGet("/health", () => "OK");
pub.MapGet("/docs", () => "Documentation");
});
// API area — full auth + rate limiting
app.Map("/api", api =>
{
api.UseAuthentication();
api.UseAuthorization();
api.UseRateLimiter();
api.MapControllers();
});
// Admin area — require admin role
app.Map("/admin", admin =>
{
admin.UseAuthentication();
admin.UseAuthorization();
admin.MapControllers().RequireAuthorization("AdminPolicy");
});Caso real: middleware de pruebas A/B
Un middleware de pruebas A/B dirige las solicitudes a distintos controladores según una cookie o un encabezado, sin modificar el código de los endpoints.
app.UseWhen(
ctx => ctx.Request.Cookies.TryGetValue("ab-group", out var g) && g == "B",
betaApp =>
{
betaApp.Use(async (ctx, next) =>
{
ctx.Items["IsGroupB"] = true;
await next(ctx);
});
});
// Endpoint reads the flag:
app.MapGet("/products", (HttpContext ctx, ProductService svc) =>
{
bool isB = ctx.Items.ContainsKey("IsGroupB");
return isB ? svc.GetNewLayoutAsync() : svc.GetOldLayoutAsync();
});Comprobación rápida
¿Cuál es la diferencia fundamental entre MapWhen y UseWhen?
Resumen: interrupciones y bifurcaciones
Conclusiones clave:
Map: bifurcación permanente basada en la ruta, sin volver a unirseMapWhen: bifurcación permanente basada en un predicadoUseWhen: bifurcación condicional que vuelve a unirse al pipeline principal- Interrupción: no llame a
next, escriba la respuesta y devuelva el control ShortCircuit()(.NET 8): endpoints terminales declarativos y optimizados- Combine bifurcaciones para crear pipelines por capas: público, API y administración
Preguntas frecuentes
¿La lección «Cortocircuito y ramificación» es gratis?
Sí — el texto completo de «Cortocircuito y ramificación» 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 «Cortocircuito y ramificación»?
Use MapWhen, UseWhen y middleware terminal para ramificar o finalizar la canalización según las condiciones de la solicitud. 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 3 de 4.
¿Cuánto tiempo toma la lección «Cortocircuito y ramificación»?
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