ASP.NET Core Middleware

Rick Anderson és Steve Smith

A middleware olyan szoftver, amely alkalmazási csővezetékbe van integrálva a kérések és válaszok kezelésére. Minden összetevő:

• Itt adhatja meg, hogy a kérést a folyamat következő összetevőjére kívánja-e továbbítani.
• A folyamat következő összetevője előtt és után is végezhet munkát.

A kérelemdelegáltak a kérelemfolyamat létrehozásához használhatók. A kérelem delegáltjai kezelik az egyes HTTP-kéréseket.

A kérésdelegáltak Run, Map, és Use bővítménymódszerekkel vannak konfigurálva. Az egyéni kérelemdelegáltak megadhatóak soron belül névtelen metódusként (úgynevezett in-line köztes szoftverként), vagy meghatározhatók egy újrafelhasználható osztályban. Ezek az újrahasználható osztályok és a soron belüli névtelen metódusok köztes szoftver, más néven köztes szoftverösszetevők. A kérelemfolyamat minden köztes szoftverösszetevője felelős a folyamat következő összetevőjének meghívásáért vagy a folyamat rövidzárolásáért. Amikor egy köztes szoftver lekapcsol, terminál köztes szoftvernek nevezik, mert megakadályozza a további köztes szoftverek kérésfeldolgozását.

A HTTP-modulok migrálása ASP.NET Core köztes szoftverbe elmagyarázza a ASP.NET Core kérésfolyamatai és a 4.x ASP.NET közötti különbséget, és további köztes szoftvermintákat biztosít.

A köztes szoftver szerepe alkalmazástípus szerint

Blazor Web Apps, Razor Pages és MVC folyamatböngésző kérések a kiszolgálón köztes szoftverrel. A cikkben szereplő útmutatás az ilyen típusú alkalmazásokra vonatkozik.

Az önálló Blazor WebAssembly-alkalmazások teljes egészében az ügyfélen futnak, és nem dolgozzák fel a kéréseket köztes szoftveres folyamattal. A cikkben szereplő útmutatás nem vonatkozik az önálló Blazor WebAssembly-alkalmazásokra.

Middleware kód elemzése

ASP.NET Core számos fordítóplatform-elemzőt tartalmaz, amelyek ellenőrzik az alkalmazás kódját a minőség szempontjából. További információ: Kódelemzés ASP.NET Core-alkalmazásokban

Köztes rétegbeli folyamatsor létrehozása WebApplication

A ASP.NET Core kérelemfolyamat a kérések delegáltjainak sorozatából áll, amelyet egymás után hívunk meg. Az alábbi ábra a koncepciót mutatja be. A végrehajtás szála a fekete nyilakat követi.

Minden meghatalmazott műveleteket hajthat végre a következő meghatalmazott előtt és után. A kivételkezelési meghatalmazottakat a folyamat korai szakaszában kell meghívni, hogy elkaphassák a folyamat későbbi szakaszaiban előforduló kivételeket.

A legegyszerűbb ASP.NET Core-alkalmazás egyetlen kérelemdelegáltat állít be, amely minden kérést kezel. Ez az eset nem tartalmaz tényleges kérelemfolyamatot. Ehelyett a rendszer egyetlen névtelen függvényt hív meg minden HTTP-kérésre válaszul.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello world!");
});

app.Run();

Több kérelemdelegált összefűzése együtt a Use-val. A next paraméter a folyamat következő delegáltját jelöli. A folyamat rövidre kapcsolásához nem meghívni a next paramétert. Általában a next delegált előtt és után is hajthat végre műveleteket, ahogy az alábbi példa is mutatja:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Use(async (context, next) =>
{
    // Do work that can write to the Response.
    await next.Invoke();
    // Do logging or other work that doesn't write to the Response.
});

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from 2nd delegate.");
});

app.Run();

A kérelemfeldolgozás megszakítása

Ha egy meghatalmazott nem ad át kérést a következő meghatalmazottnak, megszakítják a kérések folyamatát. A rövidzárolás gyakran kívánatos, mert elkerüli a szükségtelen munkát. Például a statikus fájl közbensőterminálközvetítő lehet, ha feldolgoz egy statikus fájlra vonatkozó kérést, és megszakítja a folyamat többi részét. A folyamathoz hozzáadott köztes szoftver a további feldolgozást megszakító köztes szoftver előtt továbbra is feldolgozza a kódot a next.Invoke utasítások után. Azonban tekintse meg a következő figyelmeztetést arról, hogy egy már elküldött válaszra próbál írni.

Figyelmeztetés

Ne hívja meg a next.Invoke az ügyfélnek küldött válasz alatt vagy után. Egy HttpResponse elindítása után a módosítások kivételt eredményeznek. Például, ha a fejlécek és állapotkódok beállítása megtörténik, ezek kivételt dobnak azt követően, hogy a válasz elindult. Írás a választörzsbe a nextmeghívása után:

• Protokollsértést okozhat, például ha a megadott Content-Length-nál többet ír.
• A szövegtörzs formátuma megsérülhet, például HTML-láblécet írhat egy CSS-fájlba.

HasStarted egy hasznos tipp, amely jelzi, hogy a fejlécek elküldve lettek-e, vagy a törzs írása megtörtént-e.

További információ: Rövidzárlatú köztes szoftver az útválasztás után.

Run meghatalmazottak

Run meghatalmazottak nem kapnak next paramétert. Az első Run delegált mindig végpont és lezárja az adatfolyamot. Run egy konvenció. Egyes köztes szoftverösszetevők Run[Middleware] metódusokat tehetnek elérhetővé, amelyek a folyamat végén futnak:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Use(async (context, next) =>
{
    // Do work that can write to the Response.
    await next.Invoke();
    // Do logging or other work that doesn't write to the Response.
});

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from 2nd delegate.");
});

app.Run();

Ha szeretné, hogy az angoltól eltérő nyelvekre is lefordítsuk a kódbejegyzéseket, jelezze nekünk a GitHub vitafórumának ebben aszámon szereplő témájában .

Az előző példában a Run képviselő "Hello from 2nd delegate." ír a válaszba, majd megszakítja a csővezetéket. Ha a Use delegált után egy másik Run vagy Run delegáltat adnak hozzá, azt nem hívják meg.

Részesítse előnyben az app.Use metódus túlterhelését, amely megköveteli a környezet továbbadását a következőre.

A memóriát nem foglaló app.Use kiterjesztési metódus:

• A környezet átadását igényli nextrészére.
• Két belső kérésenkénti foglalást takarít meg, amelyek a másik túlterhelésű változat használatakor szükségesek.

További információ: a GitHub-probléma.

Köztes szoftver rendelése

Az alábbi ábra a ASP.NET Core MVC- és Razor Pages-alkalmazások teljes kérelemfeldolgozási folyamatát mutatja be. Láthatja, hogy egy tipikus alkalmazásban hogyan rendezik a meglévő köztes szoftvereket, és hol adnak hozzá egyéni köztes szoftvereket. Teljes körűen szabályozhatja, hogy miként rendezheti át a meglévő köztes szoftvereket, vagy hogyan szúrhat be új, egyéni köztes szoftvereket a forgatókönyvekhez szükséges módon.

Az előző ábrán szereplő végpont köztes szoftver a megfelelő alkalmazástípushoz (MVC vagy Razor Pages) tartozó szűrőfolyamatot hajtja végre.

Az előző ábrán látható Útválasztás köztes szoftver a Statikus fájlokkövetően van bemutatva. Ez az a sorrend, amelyet a projektsablonok implementálnak alkalmazás explicit meghívásával. UseRouting. Ha nem hívja meg app.UseRouting, a Útválasztás köztes szoftver alapértelmezés szerint a folyamat elején fut. További információért lásd: Útválasztás.

A köztes szoftverösszetevők Program.cs fájlban való hozzáadásának sorrendje határozza meg a köztes szoftver összetevőinek meghívásának sorrendjét a kérelmekben, valamint a válasz fordított sorrendjét. A sorrend kritikus a biztonság, teljesítmény és funkcionalitás szempontjából.

Az alábbi kiemelt kód Program.cs a szokásos ajánlott sorrendben adja hozzá a biztonsághoz kapcsolódó köztes szoftverösszetevőket:

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using WebMiddleware.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection")
    ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();
builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseMigrationsEndPoint();
}
else
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();
// app.UseCookiePolicy();

app.UseRouting();
// app.UseRateLimiter();
// app.UseRequestLocalization();
// app.UseCors();

app.UseAuthentication();
app.UseAuthorization();
// app.UseSession();
// app.UseResponseCompression();
// app.UseResponseCaching();

app.MapRazorPages();
app.MapDefaultControllerRoute();

app.Run();

Az előző kódban:

• Az a köztes szoftver, amely nincs hozzáadva új webalkalmazások egyéni felhasználói fiókjainak létrehozása során, ki van kommentelve.
• Nem minden köztes szoftver jelenik meg pontosan ebben a sorrendben, de sokan igen. Például:
  • UseCors, UseAuthenticationés UseAuthorization a megjelenített sorrendben kell megjelennie.
  • UseCors jelenleg UseResponseCachingelőtt kell megjelennie. Ezt a követelményt GitHub dotnet/aspnetcore #23218című témakör ismerteti.
  • UseRequestLocalization minden olyan köztes szoftver előtt meg kell jelennie, amely ellenőrizheti a kultúrát a kérésekben, például app.UseStaticFiles().
  • UseRateLimiter UseRouting után kell meghívni a végpontspecifikus API-k sebességkorlátozása esetén. Ha például a [EnableRateLimiting] attribútumot használja, UseRateLimiterUseRoutingután kell meghívni. Ha csak globális korlátokat hív meg, UseRateLimiter hívható meg UseRoutingelőtt.

Bizonyos esetekben a köztes szoftver különböző sorrendben van. A gyorsítótárazás és a tömörítés sorrendje például az adott helyzethez igazodik, és több érvényes sorrend is létezik. Például:

app.UseResponseCaching();
app.UseResponseCompression();

Az előző kóddal a processzorhasználat csökkenthető a tömörített válasz gyorsítótárazásával, de előfordulhat, hogy egy erőforrás több ábrázolását is gyorsítótárazhatja különböző tömörítési algoritmusokkal, például a Gzip vagy a Brotli használatával.

A következő eljárás egyesíti a statikus fájlokat, lehetővé téve a tömörített statikus fájlok gyorsítótárazását.

app.UseResponseCaching();
app.UseResponseCompression();
app.UseStaticFiles();

Az alábbi Program.cs kód köztes szoftverösszetevőket ad hozzá a gyakori alkalmazásforgatókönyvekhez:

1. Kivétel/hibakezelés
   • Amikor az alkalmazás a fejlesztési környezetben fut:
     • A Fejlesztői Kivételkezelő Köztes Szoftver (UseDeveloperExceptionPage) jelenti az alkalmazás futási idejű hibáit.
     • Adatbázis-hibaoldal köztes réteg (UseDatabaseErrorPage) az adatbázis futásidejű hibákat észleli.
   • Amikor az alkalmazás éles környezetben fut:
     • A Exception Handler Middleware (UseExceptionHandler) a következő köztes szoftverekben szereplő kivételeket rögzíti.
     • HTTP Strict Transport Security Protocol (HSTS) Middleware (UseHsts) hozzáadja a Strict-Transport-Security fejlécet.
2. A HTTPS Redirection Middleware (UseHttpsRedirection) HTTP-kéréseket átirányít a HTTPS-be.
3. A Static File Middleware (UseStaticFiles) statikus fájlokat szolgáltat, és megszakítja a kérelmek további feldolgozását.
4. Cookie Policy Middleware (UseCookiePolicy) megfelel az alkalmazásnak az EU általános adatvédelmi rendeletének (GDPR) előírásainak.
5. Útválasztási köztes szoftver (UseRouting) a kérések átirányításához.
6. A hitelesítési köztes szoftver (UseAuthentication) megkísérli hitelesíteni a felhasználót, mielőtt hozzáférnének a biztonságos erőforrásokhoz.
7. Az engedélyezési köztes szoftver (UseAuthorization) engedélyezi a felhasználó számára a biztonságos erőforrások elérését.
8. A Session Middleware (UseSession) létrehozza és fenntartja a munkamenet állapotát. Ha az alkalmazás munkamenet-állapotot használ, hívja meg a Session Middleware-t a Policy Middleware Cookie és az MVC Middleware előtt.
9. Az Endpoint Routing Middleware (UseEndpointsMapRazorPages) segítségével Razor Pages-végpontokat adhat hozzá a kérelemfolyamathoz.

if (env.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
    app.UseDatabaseErrorPage();
}
else
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseSession();
app.MapRazorPages();

Az előző példakódban minden köztesszoftver-bővítménymetódus WebApplicationBuilder a Microsoft.AspNetCore.Builder névtéren keresztül jelenik meg.

UseExceptionHandler a folyamathoz hozzáadott első köztes szoftverösszetevő. Ezért a Exception Handler Middleware a későbbi hívások során előforduló kivételeket észleli.

A statikus fájl köztes réteget a csővezeték korai szakaszában hívjuk meg, hogy a fennmaradó összetevők megkerülésével kezelje a kéréseket és átugorja a folyamat részeit. A Static File Middleware nem biztosít engedélyezési ellenőrzéseket. A Static File Middleware által kiszolgált fájlok, beleértve a wwwrootalatti fájlokat is, nyilvánosan elérhetők. A statikus fájlok védelmének megközelítését a ASP.NET CoreStatikus fájlok című témakörben talál.

Ha a kérést nem a statikus fájlközvetítő kezeli, a rendszer a hitelesítést végző middleware-nek (UseAuthentication) továbbítja. A hitelesítés nem hagyja figyelmen kívül a hitelesítés nélküli kéréseket. Bár a Hitelesítési köztes szoftver hitelesíti a kérelmeket, az engedélyezés (és az elutasítás) csak azután történik, hogy az MVC kiválaszt egy adott Razor lap- vagy MVC-vezérlőt és műveletet.

Az alábbi példa egy köztesszoftver-sorrendet mutat be, amelyben a statikus fájlokra vonatkozó kérelmeket a statikus fájlközvetítő kezeli a választömörítési köztes szoftver előtt. A statikus fájlok nem lesznek tömörítve ezzel a köztes szoftverrendelettel. A Razor lapokra adott válaszok tömöríthetők.

// Static files aren't compressed by Static File Middleware.
app.UseStaticFiles();

app.UseRouting();

app.UseResponseCompression();

app.MapRazorPages();

Az egyoldalas alkalmazásokról az ASP.NET CoreEgyoldalas alkalmazások áttekintése című témakörben talál további információt.

UseCors és UseStaticFiles sorrendje

A UseCors és UseStaticFiles hívásának sorrendje az alkalmazástól függ. További információ: UseCors és UseStaticFiles sorrend

Továbbított fejlécek köztes szoftver sorrendje

A továbbított fejlécek köztes szoftvernek a többi köztes szoftver előtt kell futnia. Ez a rendezés biztosítja, hogy a továbbított fejlécekre támaszkodó köztes szoftver feldolgozhassa a fejlécértékeket. A továbbított fejlécek köztes szoftver diagnosztikát és hibakezelést követő futtatásához lásd a Továbbított fejlécek köztes szoftver sorrendjerészt.

A köztes szoftverfolyamat elágaztatása

A Map kiterjesztések a csővezeték elágaztatásának konvenciójaként használatosak. Map elágaztatja a kérelemfolyamatot az adott kérelemútvonal egyezései alapján. Ha a kérelem elérési útja a megadott elérési úttal kezdődik, a rendszer végrehajtja az ágat.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Map("/map1", HandleMapTest1);

app.Map("/map2", HandleMapTest2);

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from non-Map delegate.");
});

app.Run();

static void HandleMapTest1(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        await context.Response.WriteAsync("Map Test 1");
    });
}

static void HandleMapTest2(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        await context.Response.WriteAsync("Map Test 2");
    });
}

Az alábbi táblázat az előző kód használatával http://localhost:1234 kéréseit és válaszait mutatja be.

Kérés	Válasz
localhost:1234	Üdvözlet a nem-térkép delegáltjától.
localhost:1234/map1	Térképteszt 1
localhost:1234/map2	Térképteszt 2
localhost:1234/map3	Üdvözlet a nem-térkép delegáltjától.

Ha a(z) Map-t használnak, eltávolítják a megfeleltetett elérésiút-szegmenseket a HttpRequest.Path-ből, és hozzáfűzik a HttpRequest.PathBase-höz minden kérésnél.

Map például támogatja a beágyazást:

app.Map("/level1", level1App => {
    level1App.Map("/level2a", level2AApp => {
        // "/level1/level2a" processing
    });
    level1App.Map("/level2b", level2BApp => {
        // "/level1/level2b" processing
    });
});

Map egyszerre több szegmensnek is megfelelhet:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Map("/map1/seg1", HandleMultiSeg);

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from non-Map delegate.");
});

app.Run();

static void HandleMultiSeg(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        await context.Response.WriteAsync("Map Test 1");
    });
}

MapWhen elágaztatja a kérelemfolyamatot az adott predikátum eredménye alapján. A bármilyen Func<HttpContext, bool> típusú predikátum felhasználható a kérések folyamat egy új ágára való leképezésére. Az alábbi példában egy predikátumot használunk egy lekérdezési sztringváltozó jelenlétének észlelésére branch:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapWhen(context => context.Request.Query.ContainsKey("branch"), HandleBranch);

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from non-Map delegate.");
});

app.Run();

static void HandleBranch(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        var branchVer = context.Request.Query["branch"];
        await context.Response.WriteAsync($"Branch used = {branchVer}");
    });
}

Az alábbi táblázat az előző kód használatával http://localhost:1234 kéréseit és válaszait mutatja be:

Kérés	Válasz
localhost:1234	Hello from non-Map delegate.
localhost:1234/?branch=main	Branch used = main

UseWhen a kérelemfolyamatot is elágaztatja az adott predikátum eredménye alapján. A MapWhenellentétben ez az ág újra csatlakozik a fő folyamathoz, ha nem tartalmaz terminál köztes szoftvereket:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseWhen(context => context.Request.Query.ContainsKey("branch"),
    appBuilder => HandleBranchAndRejoin(appBuilder));

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from non-Map delegate.");
});

app.Run();

void HandleBranchAndRejoin(IApplicationBuilder app)
{
    var logger = app.ApplicationServices.GetRequiredService<ILogger<Program>>(); 

    app.Use(async (context, next) =>
    {
        var branchVer = context.Request.Query["branch"];
        logger.LogInformation("Branch used = {branchVer}", branchVer);

        // Do work that doesn't write to the Response.
        await next();
        // Do other work that doesn't write to the Response.
    });
}

Az előző példában a Hello from non-Map delegate. válasza minden kéréshez meg van írva. Ha a kérés tartalmaz egy branchlekérdezési sztringváltozót, annak értékét a rendszer naplózza a főfolyamat újbóli összekapcsolása előtt.

Beépített köztes szoftver

Az ASP.NET Core a következő middleware komponenseket tartalmazza. A Order oszlop a köztes szoftvernek a kérelemfeldolgozási folyamatban való elhelyezésével kapcsolatos megjegyzéseket tartalmaz, valamint azt, hogy a köztes szoftver milyen feltételek mellett fejezheti be a kérelmek feldolgozását. Amikor egy köztes szoftver rövidzárlatot ad a kérésfeldolgozó folyamatnak, és megakadályozza a további alsóbb rétegbeli köztes szoftvereket a kérések feldolgozásában, terminál köztes szoftvernek nevezzük. További információ a rövidzárolásról a WebApplication köztes szoftveres folyamat létrehozása című részben található.

Köztes szoftver	Leírás	Megrendelés
Hamisítás elleni védelem	Kérés-hamisítás elleni támogatást nyújt.	Hitelesítés és engedélyezés után, végpontok előtt.
Hitelesítés	Hitelesítési támogatást nyújt.	Mielőtt szükség lenne HttpContext.User-ra. OAuth-visszahívások terminálja.
Engedélyezés	Engedélyezési támogatást nyújt.	Közvetlenül a hitelesítési köztes szoftver után.
Cookie szabályzat	Nyomon követi a felhasználók hozzájárulását a személyes adatok tárolásához, és betartatja cookie mezőkre vonatkozó minimális szabványokat, például secure és SameSite.	A köztes szoftver előtt, amely cookie-kat ad ki. Példák: Hitelesítés, Munkamenet, MVC (TempData).
CORS	A forrásközi erőforrásmegosztást konfigurálja.	A CORS-t használó összetevők előtt. UseCors jelenleg UseResponseCachingmiatt, előtt kell lennie.
FejlesztőiKivételOldal	Létrehoz egy olyan oldalt, amelyen hibainformációk találhatók, amelyek csak a fejlesztési környezetben való használatra szolgálnak.	A hibákat generáló összetevők előtt. A projektsablonok automatikusan regisztrálják ezt a köztes szoftvert a folyamat első köztes szoftvereként, amikor a környezet fejlesztés.
Diagnosztikai	Több különálló köztes szoftver, amely fejlesztői kivételoldalt, kivételkezelést, állapotkódlapokat és az új alkalmazások alapértelmezett weblapját biztosítja.	A hibákat generáló összetevők előtt. Terminál a kivételekhez, vagy az új alkalmazások alapértelmezett weblapjának kiszolgálása.
továbbított fejlécek	Továbbítja a proxizált fejléceket az aktuális kéréshez.	A frissített mezőket felhasználó komponensek előtt. Példák: séma, gazdagép, ügyfél IP-címe, módszer.
Egészségügyi ellenőrzés	Ellenőrzi egy ASP.NET Core-alkalmazás állapotát és függőségeit, például az adatbázis rendelkezésre állásának ellenőrzését.	Terminál, ha egy kérés megfelel egy állapot-ellenőrzési végpontnak.
Fejléc terjesztése	Propagálja a HTTP-fejléceket a bejövő kérésből a kimenő HTTP-ügyfélkérelmekbe.
HTTP-naplózás	HTTP-kéréseket és válaszokat naplóz.	A middleware folyamatának elején.
HTTP-metódus felülbírálása	Lehetővé teszi, hogy egy bejövő POST-kérés felülbírálja a metódust.	A frissített metódust használó összetevők előtt.
HTTPS-átirányítás	Az összes HTTP-kérés átirányítása HTTPS-be.	Az URL-t fogyasztó összetevők előtt.
HTTP szigorú átviteli biztonsági (HSTS)	Biztonsági fejlesztést biztosító köztes szoftver, amely hozzáad egy speciális válaszfejlécet.	A válaszok elküldése előtt és a kéréseket módosító összetevők után. Példák: Továbbított fejlécek, URL-átírás.
MVC	MVC/Razor pages használatával dolgozza fel a kérelmeket.	Terminál, ha egy kérés megfelel egy útvonalnak.
OWIN	Együttműködés OWIN-alapú alkalmazásokkal, kiszolgálókkal és köztes szoftverekkel.	Terminál, ha az OWIN Middleware teljes mértékben feldolgozza a kérést.
Kimeneti gyorsítótárazás	Támogatja a konfiguráción alapuló gyorsítótárazási válaszokat.	Gyorsítótárazást igénylő összetevők előtt. UseRouting UseOutputCachingelőtt kell lennie. UseCORS UseOutputCachingelőtt kell lennie.
válasz gyorsítótárazása	Támogatást nyújt a gyorsítótárazási válaszokhoz. Ehhez az ügyfél részvétele szükséges. A teljes kiszolgálóvezérléshez használjon kimeneti gyorsítótárazást.	Gyorsítótárazást igénylő összetevők előtt. UseCORS UseResponseCachingelőtt kell lennie. Általában nem előnyös az olyan felhasználói felületi alkalmazások esetében, mint a Razor Pages, mivel a böngészők általában olyan kérésfejléceket állítanak be, amelyek megakadályozzák a gyorsítótárazást. Kimeneti gyorsítótárazás előnyös a felhasználói felületű alkalmazásoknak.
Dekompresszió kérése	Támogatást nyújt a kérések kitömörítéséhez.	A kérelem törzsét olvasó összetevők előtt.
Választömörítés	Támogatja a válaszok tömörítését.	A tömörítést igénylő összetevők előtt.
Honosítási kérelem	Honosítási támogatást nyújt.	A honosítás előtt az érzékeny összetevőket. Az útválasztás köztes szoftver után kell megjelennie RouteDataRequestCultureProvider használatakor.
Kérelem időtúllépés	Támogatást nyújt a kérelmek időtúllépéseinek konfigurálásához globálisan és végpontonként.	UseRequestTimeouts UseExceptionHandler, UseDeveloperExceptionPageés UseRoutingután kell érkeznie .
Végpont-útválasztás	Meghatározza és korlátozza a kérési útvonalakat.	Az útvonalak illesztésére szolgáló terminál.
GYÓGYFÜRDŐ	A köztes szoftverlánc ezen pontjáról érkező összes kérést az egyoldalas alkalmazás (SPA) alapértelmezett oldalának visszaadásával kezeli.	A lánc későbbi részében, így a statikus fájlok, MVC-műveletek stb. kiszolgálására szolgáló többi köztes szoftver elsőbbséget kap.
szekció	Támogatást nyújt a felhasználói munkamenetek kezeléséhez.	A munkamenetet igénylő összetevők előtt.
statikus fájlok	Támogatja a statikus fájlok és a címtárböngészés kiszolgálását.	Terminál, ha egy kérés egy fájlnak felel meg.
URL-cím átírása	Támogatja az URL-címek újraírását és a kérések átirányítását.	Az URL-t fogyasztó összetevők előtt.
W3CLogging	Kiszolgálóelérési naplókat hoz létre a W3C bővített naplófájlformátumú.	A middleware folyamatának elején.
WebSockets	Engedélyezi a WebSockets protokollt.	A WebSocket-kérelmek elfogadásához szükséges összetevők előtt.

További erőforrások

• élettartam- és regisztrációs lehetőségek a köztes szoftver teljes mintáját tartalmazza, hatókörrel rendelkező, átmenetiés egyszeri élettartam-szolgáltatásokkal.
• Egyéni ASP.NET Core köztes szoftver írása
• ASP.NET Core köztes szoftver tesztelése
• gRPC-Web konfigurálása az ASP.NET Core-ban
• HTTP-modulok migrálása ASP.NET Core köztes szoftverbe
• alkalmazás indítása a ASP.NET Core
• Kért funkciók az ASP.NET Core-ban
• Factory alapú middleware aktiválás ASP.NET Core-ban
• Köztes szoftver aktiválása harmadik féltől származó tárolóval az ASP.NET Core