PricingLoginStart free
C# Academy · Oppitunti

Putken oikosulkeminen ja haaroittaminen

Käyttäkää MapWhen-, UseWhen- ja päätösmiddlewarea putken haaroittamiseen tai lopettamiseen pyyntöehtojen perusteella.

Oppitunti 3/412 vaihetta

Putken oikosulkeminen ja haaroittaminen on ilmainen C# Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu C# Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. C# Academy-kurssilla on yhteensä 4 oppituntia.

Haarautuminen ja putken käsittelyn katkaiseminen

Kaikkien pyyntöjen ei tarvitse kulkea koko middleware-putken läpi. ASP.NET Core tarjoaa työkalut haarauttamiseen, jolla pyyntöjoukot ohjataan eri putkiin, sekä käsittelyn katkaisemiseen, jolla käsittely lopetetaan ja vastaus palautetaan heti.

Map: pysyvä polkuhaara

Map luo pysyvän haaran — etuliitteen täsmäävät pyynnöt siirtyvät haaraan eivätkä KOSKAAN palaa pääputkeen.

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: haarautuminen predikaatin perusteella

MapWhen haarauttaa käsittelyn minkä tahansa ehdon, kuten otsakkeiden, kyselyparametrien tai mukautetun logiikan, perusteella. Kuten Map, myös tämä haara on pysyvä eikä liity takaisin pääputkeen.

// 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: takaisin liittyvä ehdollinen haara

UseWhen toimii kuten MapWhen, mutta haara liittyy takaisin pääputkeen suorituksensa jälkeen. Näin middleware-komponentteja voidaan lisätä ehdollisesti ilman putken haarautumista pysyvästi.

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

Käsittelyn katkaiseminen jättämällä next kutsumatta

Mikä tahansa middleware-komponentti voi katkaista käsittelyn kirjoittamalla vastauksen ja jättämällä next-komponentin kutsumatta. Putki päättyy siihen, ja vastaus palautetaan asiakkaalle.

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

.NET 8:ssa MapShortCircuit ja päätepisteiden ShortCircuit()-laajennus tarjoavat deklaratiivisen ja erittäin optimoidun tavan katkaista käsittely.

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

Päättävä middleware ja endpoint-reititys

Ennen .NET 3:a app.Run() oli ainoa päättävä vaihtoehto. Nykyään endpoint-reititystä (MapGet, MapControllers) suositellaan, koska se osallistuu valtuutukseen, nopeusrajoitukseen ja metatietojen käsittelyyn.

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

Polkujen täsmäytyksen yksityiskohdat

Map("/api") täsmää polkuihin /api ja /api/anything. Täsmäytetty polku poistetaan haaran sisällä ominaisuudesta Request.Path ja siirretään ominaisuuteen 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);
});

Haarautumismallien yhdistäminen

Oikeat sovellukset yhdistävät Map-, UseWhen- ja käsittelyn katkaisuja rakentaakseen kerroksittaisia putkia: julkiset reitit ovat kevyitä, API-reitit sisältävät autentikoinnin ja ylläpitäjän reiteillä on lisätarkistuksia.

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

Käytännössä: A/B-testausmiddleware

A/B-testausmiddleware haarauttaa pyynnöt eri käsittelijöille evästeen tai otsakkeen perusteella ilman, että päätepisteiden koodia tarvitsee muuttaa.

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

Pikatarkistus

Mikä on keskeinen ero MapWhen- ja UseWhen-kutsujen välillä?

Vastaa interaktiivisessa oppitunnissa

Kertaus: Käsittelyn katkaiseminen ja haarautuminen

Keskeiset opit:

  • Map: pysyvä polkuun perustuva haara, joka ei liity takaisin
  • MapWhen: pysyvä predikaattiin perustuva haara
  • UseWhen: ehdollinen haara, joka liittyy takaisin pääputkeen
  • Käsittelyn katkaiseminen: älkää kutsuko next-komponenttia, vaan kirjoittakaa vastaus ja palatkaa
  • ShortCircuit() (.NET 8): deklaratiiviset ja optimoidut päätepisteet
  • Yhdistäkää haarautumismalleja kerroksittaisten putkien rakentamiseen: julkiset / API / ylläpitäjän reitit
Aloita maksutta

Opi C# tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit
93
Oppitunnit
346
Aloita opiskelu maksuttaNäytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Putken oikosulkeminen ja haaroittaminen” ilmainen?

Kyllä – oppitunnin ”Putken oikosulkeminen ja haaroittaminen” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko C# Academy-kurssin, päivitä CoddyKit PROhon. C# Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Putken oikosulkeminen ja haaroittaminen”?

Käyttäkää MapWhen-, UseWhen- ja päätösmiddlewarea putken haaroittamiseen tai lopettamiseen pyyntöehtojen perusteella. Harjoittelet C# Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni C# Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin C# Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Putken oikosulkeminen ja haaroittaminen”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä C# Academy-oppitunnilla?

Kyllä. Jokainen C# Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

  1. ASP.NET Coren putken yleiskatsaus
  2. Mukautetun middlewaren kirjoittaminen
  3. Putken oikosulkeminen ja haaroittaminen
  4. Middlewaren järjestys ja sisäänrakennettu middleware
← Takaisin: C# Academy