C# Academy · leksjon

Kortslutning og forgrening

Bruk MapWhen, UseWhen og terminal middleware til å forgrene eller avslutte pipelinen basert på betingelser i forespørselen.

Leksjon 3 av 412 trinn

Kortslutning og forgrening er en gratis leksjon i C# Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C# Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C# Academy inneholder totalt 4 leksjoner.

Forgrening og kortslutting

Ikke alle forespørsler bør gå gjennom hele middleware-pipelinen. ASP.NET Core tilbyr verktøy for å forgrene forespørsler, slik at delmengder rutes til ulike pipeliner, og for å kortslutte ved å stoppe behandlingen og returnere umiddelbart.

Map: Permanent forgrening basert på sti

Map oppretter en permanent forgrening – forespørsler som samsvarer med prefikset, går inn i forgreningen og kommer ALDRI tilbake til hovedpipelinen.

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: Forgrening basert på predikat

MapWhen forgrener basert på en hvilken som helst betingelse, for eksempel headere, query-parametere eller egendefinert logikk. I likhet med Map er forgreningen permanent – den kobles ikke tilbake til hovedpipelinen.

// 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: Betinget forgrening som kobles tilbake

UseWhen ligner på MapWhen, men forgreningen kobles tilbake til hovedpipelinen når den er ferdig. Dette gjør det mulig å legge til middleware betinget uten å lage en separat gren.

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

Kortslutting ved å ikke kalle Next

Ethvert middleware kan kortslutte ved å skrive til responsen og ikke kalle next. Pipelinen stopper på dette punktet, og responsen returneres til klienten.

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() i .NET 8

I .NET 8 tilbyr MapShortCircuit og utvidelsen ShortCircuit() på endepunkter en deklarativ, svært optimalisert kortslutningsbane.

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

Terminal middleware kontra endepunktruting

Før .NET 3 var app.Run() det eneste terminalalternativet. Nå foretrekkes endepunktruting (MapGet, MapControllers) – den deltar i autorisasjon, rate limiting og metadata.

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

Nyanser ved stisamsvar

Map("/api") samsvarer med /api og /api/anything. Den samsvarte delen av stien fjernes fra Request.Path i forgreningen og plasseres i 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);
});

Kombinere forgreningsmønstre

Virkelige apper kombinerer Map, UseWhen og kortslutninger for å lage lagdelte pipeliner: offentlige ruter er lette, API-ruter har autentisering, og admin-ruter har ekstra kontroller.

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

I praksis: Middleware for A/B-testing

Middleware for A/B-testing forgrener forespørsler til ulike behandlere basert på en informasjonskapsel eller header, uten å endre endepunktkoden.

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

Kunnskapssjekk

Hva er den viktigste forskjellen mellom MapWhen og UseWhen?

Besvar den i den interaktive leksjonen

Oppsummering: Kortslutting og forgrening

Viktigste punkter:

Map: permanent sti-basert forgrening uten tilbakekobling
MapWhen: permanent predikatbasert forgrening
UseWhen: betinget forgrening som kobles tilbake til hovedpipelinen
Kortslutting: ikke kall next, skriv responsen og returner
ShortCircuit() (.NET 8): deklarative, optimaliserte terminale endepunkter
Kombiner forgreninger for å bygge lagdelte pipeliner: offentlige ruter / API / admin

Gratis å komme i gang

Lær deg C# med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 93
Leksjoner: 346

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Kortslutning og forgrening» gratis?

Ja – hele teksten i «Kortslutning og forgrening» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av C# Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i C# Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Kortslutning og forgrening»?

Bruk MapWhen, UseWhen og terminal middleware til å forgrene eller avslutte pipelinen basert på betingelser i forespørselen. Du øver på C# Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C# Academy?

Ingen tidligere erfaring er nødvendig. C# Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Kortslutning og forgrening»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C# Academy-leksjonen?

Ja. Alle C# Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til C# Academy