Cachelagring av svar i ASP.NET Core

Visa eller ladda ned exempelkod (hur du laddar ned)

Cachelagring av svar minskar antalet begäranden som en klient eller proxy gör till en webbserver. Cachelagring av svar minskar också mängden arbete som webbservern utför för att generera ett svar. Cachelagring av svar anges i rubriker.

Attributet ResponseCache anger cachelagringshuvuden för svar. Klienter och mellanliggande proxyservrar bör respektera rubrikerna för cachelagringssvar under RFC 9111: HTTP-cachelagring.

För cachelagring på serversidan som följer http 1.1-cachelagringsspecifikationen använder du Mellanprogram för svarscachelagring. Mellanprogrammet kan använda ResponseCacheAttribute egenskaperna för att påverka cachelagringsbeteendet på serversidan.

Mellanprogrammet För cachelagring av svar:

• Aktiverar cachelagring av serversvar baserat på HTTP-cachehuvuden. Implementerar standard-HTTP-cachelagringssemantik. Cacheminnen baserade på HTTP-cachehuvuden som proxyservrar gör.
• Är vanligtvis inte fördelaktigt för användargränssnittsappar som Razor Pages eftersom webbläsare vanligtvis anger begärandehuvuden som förhindrar cachelagring. Cachelagring av utdata, som är tillgängligt i .NET 7 eller senare, gynnar användargränssnittsappar. Med cachelagring av utdata bestämmer konfigurationen vad som ska cachelagras oberoende av HTTP-huvuden.
• Kan vara fördelaktigt för offentliga GET- eller HEAD API-begäranden från klienter där villkor för cachelagring uppfylls.

Om du vill testa cachelagring av svar använder du Fiddlereller ett annat verktyg som uttryckligen kan ange begärandehuvuden. Att ange rubriker uttryckligen är att föredra för testning av cachelagring. Mer information finns i Felsökning.

HTTP-baserad cachelagring av svar

RFC 9111: HTTP-cachelagring beskriver hur Internetcacheminnen ska fungera. Det primära HTTP-huvudet som används för cachelagring är Cache-Control, som används för att ange cachedirektiv. Direktiven styr cachelagringsbeteendet när begäranden går från klienter till servrar och när svar går från servrar tillbaka till klienter. Begäranden och svar flyttas via proxyservrar, och proxyservrar måste också överensstämma med HTTP 1.1-cachelagringsspecifikationen.

Vanliga Cache-Control direktiv visas i följande tabell.

Andra cachehuvuden som spelar en roll i cachelagring visas i följande tabell.

HTTP-baserad cachelagring respekterar direktiv för begäran Cache-Control

RFC 9111: HTTP-cachelagring (avsnitt 5.2. Cache-Control) kräver att en cache respekterar ett giltigt Cache-Control header som skickas av klienten. En klient kan göra begäranden med ett no-cache huvudvärde och tvinga servern att generera ett nytt svar för varje begäran.

Att alltid respektera klientbegäran Cache-Control är meningsfullt om du tänker på målet med HTTP-cachning. Enligt den officiella specifikationen är cachelagring avsedd att minska svarstiden och nätverkskostnaderna för att tillfredsställa begäranden i ett nätverk av klienter, proxyservrar och servrar. Det är inte nödvändigtvis ett sätt att styra belastningen på en ursprungsserver.

Det finns ingen utvecklarkontroll över det här cachelagringsbeteendet när du använder Mellanprogram för svarscachelagring eftersom mellanprogrammet följer den officiella cachelagringsspecifikationen. Stöd för cachelagring av utdata till bättre kontrollserverbelastning lades till i .NET 7. Mer information finns i cachelagring av utdata.

ResponseCache-attributet

ResponseCacheAttribute Anger de parametrar som krävs för att ange lämpliga rubriker i svarscachelagring.

VaryByQueryKeys varierar det lagrade svaret efter värdena i den angivna listan med frågenycklar. När ett enda värde anges * varierar mellanprogrammet svar efter alla frågesträngsparametrar för begäran.

Cachelagring av svar mellanprogram måste vara aktiverat för att ställa in egenskapen VaryByQueryKeys . Annars genereras ett körningsundundatag. Det finns inget motsvarande HTTP-huvud för egenskapen VaryByQueryKeys . Egenskapen är en HTTP-funktion som hanteras av svars-cachelagring med mellanvara. För att mellanprogrammet ska kunna hantera ett cachelagrat svar måste frågesträngen och frågesträngsvärdet matcha en tidigare begäran. Tänk till exempel på sekvensen med begäranden och resultat som visas i följande tabell:

Den första begäran returneras av servern och cachelagras i mellanprogram. Den andra begäran returneras av mellanprogram eftersom frågesträngen matchar den tidigare begäran. Den tredje begäran finns inte i cacheminnet för mellanprogram eftersom frågesträngsvärdet inte matchar en tidigare begäran.

ResponseCacheAttribute Används för att konfigurera och skapa (via IFilterFactory) en Microsoft.AspNetCore.Mvc.Internal.ResponseCacheFilter. Utför ResponseCacheFilter arbetet med att uppdatera lämpliga HTTP-huvuden och funktioner i svaret. Filtret:

• Tar bort alla befintliga rubriker för Vary, Cache-Controloch Pragma.
• Skriver ut lämpliga rubriker baserat på egenskaperna som anges i ResponseCacheAttribute.
• Uppdaterar HTTP-funktionen för cachelagring av svar, om VaryByQueryKeys är inställd.

Vary

Det här rubriken skrivs bara när egenskapen VaryByHeader har angetts. Egenskapen är inställd på egenskapens Vary värde. Följande exempel använder egenskapen VaryByHeader :

[ApiController]
public class TimeController : ControllerBase
{
    [Route("api/[controller]")]
    [HttpGet]
    [ResponseCache(VaryByHeader = "User-Agent", Duration = 30)]
    public ContentResult GetTime() => Content(
                      DateTime.Now.Millisecond.ToString());

Visa svarshuvudena med Fiddler eller något annat verktyg. Svarshuvudena är:

Cache-Control: public,max-age=30
Vary: User-Agent

Föregående kod kräver att du lägger till Tjänsterna för cachelagring av svar i AddResponseCaching tjänstsamlingen och konfigurerar appen att använda mellanprogrammet med UseResponseCaching tilläggsmetoden.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddResponseCaching();

var app = builder.Build();

app.UseHttpsRedirection();

// UseCors must be called before UseResponseCaching
//app.UseCors();

app.UseResponseCaching();

app.UseAuthorization();

app.MapControllers();

app.Run();

NoStore och Location.None

NoStore åsidosätter de flesta av de andra egenskaperna. När den här egenskapen är inställd på trueCache-Control är rubriken inställd på no-store. Om Location är inställt på None:

• Cache-Control är inställt på no-store,no-cache.
• Pragma är inställt på no-cache.

Om NoStore är false och Location är None, Cache-Control, och Pragma är inställda på no-cache.

NoStore är vanligtvis inställt på true för felsidor. Följande genererar svarshuvuden som instruerar klienten/användaren att inte spara svaret.

[Route("api/[controller]/ticks")]
[HttpGet]
[ResponseCache(Location = ResponseCacheLocation.None, NoStore = true)]
public ContentResult GetTimeTicks() => Content(
                  DateTime.Now.Ticks.ToString());

Föregående kod innehåller följande rubriker i svaret:

Cache-Control: no-store,no-cache
Pragma: no-cache

Om du vill tillämpa ResponseCacheAttribute på alla MVC-kontrollanter i appen eller Razor sidsvar, lägger du till den med ett MVC-filter eller Razor sidfilter.

I en MVC-app:

builder.Services.AddControllersWithViews().AddMvcOptions(options => 
    options.Filters.Add(
        new ResponseCacheAttribute
        {
            NoStore = true, 
            Location = ResponseCacheLocation.None
        }));

En metod som gäller för Razor Pages-appar finns under Att lägga till ResponseCacheAttribute i den globala MVC-filterlistan gäller inte för Razor Pages (dotnet/aspnetcore #18890). Exemplet som angavs i ärendekommentären skrevs för appar som riktar sig till ASP.NET Core innan minimala API:er släpptes kl. 6.0. För appar med 6.0 eller senare ändrar du tjänstregistreringen i exemplet till builder.Services.AddSingleton... för Program.cs.

Plats och varaktighet

Om du vill aktivera cachelagring Duration måste du ange ett positivt värde och Location måste vara antingen Any (standardvärdet) eller Client. Ramverket anger header till platsvärdet följt av responsen.

Locations alternativ för Any och Client motsvarar rubrikvärdena Cache-Control med public respektive private. Som angett i avsnittet NoStore och Location.None, när du ställer in Location till None, ställer du in både Cache-Control och Pragma-huvuden till no-cache.

Location.Any (Cache-Control inställt på public) anger att klienten eller någon mellanliggande proxy kan cachelagra värdet, inklusive Mellanprogram för svarscachelagring.

Location.Client (Cache-Control inställt på private) anger att endast klienten kan cachelagrar värdet. Ingen mellanliggande cache ska cachelagra värdet, inklusive Response Caching Middleware.

Cachekontrollrubriker ger vägledning till klienter och mellanliggande proxyservrar när och hur du cachelagrar svar. Det finns ingen garanti för att klienter och proxyservrar kommer att respektera RFC 9111: HTTP-cachelagring. Cachelagring av svar Mellanprogram följer alltid de cachelagringsregler som anges i specifikationen.

I följande exempel visas rubrikerna som skapas genom att ange Duration och lämna standardvärdet Location :

[Route("api/[controller]/ms")]
[HttpGet]
[ResponseCache(Duration = 10, Location = ResponseCacheLocation.Any, NoStore = false)]
public ContentResult GetTimeMS() => Content(
                  DateTime.Now.Millisecond.ToString());

Föregående kod innehåller följande rubriker i svaret:

Cache-Control: public,max-age=10

Cache-profiler

I stället för att duplicera inställningarna för svarscache på många kontrollantåtgärdsattribut kan cacheprofiler konfigureras som alternativ när du konfigurerar MVC/Razor Pages. Värden som finns i en refererad cacheprofil används som standardvärden för ResponseCacheAttribute och åsidosätts av alla egenskaper som anges i attributet.

I följande exempel visas en cacheprofil på 30 sekunder:

using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddResponseCaching();
builder.Services.AddControllers(options =>
{
    options.CacheProfiles.Add("Default30",
        new CacheProfile()
        {
            Duration = 30
        });
});

var app = builder.Build();

app.UseHttpsRedirection();

// UseCors must be called before UseResponseCaching
//app.UseCors();

app.UseResponseCaching();

app.UseAuthorization();

app.MapControllers();

app.Run();

Följande kod refererar till Default30 cacheprofilen:

[ApiController]
[ResponseCache(CacheProfileName = "Default30")]
public class Time2Controller : ControllerBase
{
    [Route("api/[controller]")]
    [HttpGet]
    public ContentResult GetTime() => Content(
                      DateTime.Now.Millisecond.ToString());

    [Route("api/[controller]/ticks")]
    [HttpGet]
    public ContentResult GetTimeTicks() => Content(
                      DateTime.Now.Ticks.ToString());
}

Det resulterande huvudsvaret från Default30 cacheprofilen innehåller:

Cache-Control: public,max-age=30

Attributet [ResponseCache] kan tillämpas på:

• Razor Sidor: Attributen kan inte tillämpas på hanteringsmetoder. Webbläsare som används med användargränssnittsappar förhindrar cachelagring av svar.
• MVC-styrenheter.
• MVC-åtgärdsmetoder: Attribut på metodnivå åsidosätter de inställningar som anges i attribut på klassnivå.

Följande kod tillämpar [ResponseCache] attributet på kontrollantnivå och metodnivå:

[ApiController]
[ResponseCache(VaryByHeader = "User-Agent", Duration = 30)]
public class Time4Controller : ControllerBase
{
    [Route("api/[controller]")]
    [HttpGet]
    public ContentResult GetTime() => Content(
                      DateTime.Now.Millisecond.ToString());

    [Route("api/[controller]/ticks")]
    [HttpGet]
    public ContentResult GetTimeTicks() => Content(
                  DateTime.Now.Ticks.ToString());

    [Route("api/[controller]/ms")]
    [HttpGet]
    [ResponseCache(Duration = 10, Location = ResponseCacheLocation.Any, NoStore = false)]
    public ContentResult GetTimeMS() => Content(
                      DateTime.Now.Millisecond.ToString());
}

Ytterligare resurser

• Lagra svar i cacheminnen
• Cache-Control
• Cache i minnet i ASP.NET Core
• Distribuerad cachelagring i ASP.NET Core
• Identifiera ändringar med ändringstoken i ASP.NET Core
• Mellanprogram för cachelagring av svar i ASP.NET Core
• Hjälp för cachetaggen i ASP.NET Core MVC
• Tagghjälparen för distribuerad cache i ASP.NET Core

Visa eller ladda ned exempelkod (hur du laddar ned)

Cachelagring av svar minskar antalet begäranden som en klient eller proxy gör till en webbserver. Cachelagring av svar minskar också mängden arbete som webbservern utför för att generera ett svar. Cachelagring av svar styrs av rubriker som anger hur du vill att klient-, proxy- och mellanprogram ska cachelagra svar.

Deltar [ResponseCache] i att ställa in headers för respons-cachelagring. Klienter och mellanliggande proxyservrar bör respektera rubrikerna för cachelagringssvar under RFC 9111: HTTP-cachelagring.

För cachelagring på serversidan som följer http 1.1-cachelagringsspecifikationen använder du Mellanprogram för svarscachelagring. Mellanprogrammet kan använda [ResponseCache] egenskaperna för att ange cachelagringshuvuden på serversidan.

HTTP-baserad cachelagring av svar

RFC 9111: HTTP-cachelagring beskriver hur Internetcacheminnen ska fungera. Det primära HTTP-huvudet som används för cachelagring är Cache-Control, som används för att ange cachedirektiv. Direktiven styr cachelagringsbeteendet när begäranden går från klienter till servrar och när svar går från servrar tillbaka till klienter. Begäranden och svar flyttas via proxyservrar, och proxyservrar måste också överensstämma med HTTP 1.1-cachelagringsspecifikationen.

Vanliga Cache-Control direktiv visas i följande tabell.

Andra cachehuvuden som spelar en roll i cachelagring visas i följande tabell.

HTTP-baserad cachelagring respekterar direktiv för begäran Cache-Control

RFC 9111: HTTP-cachelagring (avsnitt 5.2. Cache-Control) kräver att en cache respekterar ett giltigt Cache-Control header som skickas av klienten. En klient kan göra begäranden med ett no-cache huvudvärde och tvinga servern att generera ett nytt svar för varje begäran.

Att alltid respektera klientbegäran Cache-Control är meningsfullt om du tänker på målet med HTTP-cachning. Enligt den officiella specifikationen är cachelagring avsedd att minska svarstiden och nätverkskostnaderna för att tillfredsställa begäranden i ett nätverk av klienter, proxyservrar och servrar. Det är inte nödvändigtvis ett sätt att styra belastningen på en ursprungsserver.

Det finns ingen utvecklarkontroll över det här cachelagringsbeteendet när du använder Mellanprogram för svarscachelagring eftersom mellanprogrammet följer den officiella cachelagringsspecifikationen. Stöd för cachelagring av utdata till bättre kontrollserverbelastning är ett designförslag för en framtida version av ASP.NET Core. Mer information finns i Lägga till stöd för cachelagring av utdata (dotnet/aspnetcore #27387).

Annan cachelagringsteknik i ASP.NET Core

Cachelagring i minnet

Minnesintern cachelagring använder serverminne för att lagra cachelagrade data. Den här typen av cachelagring är lämplig för en enskild server eller flera servrar med hjälp av sessionstillhörighet. Sessionstillhörighet kallas även ihållande sessioner. Sessionstillhörighet innebär att begäranden från en klient alltid dirigeras till samma server för bearbetning.

För mer information, se Cache in-memory i ASP.NET Core och Felsök Azure Application Gateway-session samhörighetsproblem.

Distribuerad cache

Använd en distribuerad cache för att lagra data i minnet när appen finns i ett moln eller en servergrupp. Cacheminnet delas mellan de servrar som bearbetar begäranden. En klient kan skicka en begäran som hanteras av valfri server i gruppen om cachelagrade data för klienten är tillgängliga. ASP.NET Core fungerar med SQL Server, Redis, Postgres och distribuerade NCache-cacheminnen .

Mer information finns i distribuerad cachelagring i ASP.NET Core.

Hjälp om cachetaggen

Cacha innehållet från en MVC-vy eller Razor Page med Cache Tag Helper. Hjälpen för cachetaggen använder minnesintern cachelagring för att lagra data.

Mer information finns i Cache Tag Helper i ASP.NET Core MVC.

Hjälp för distribuerad cachetagg

Cache-lagra innehåll från en MVC-vy eller Razor-sida i distribuerade moln- eller webbgruppsscenarier med Distributed Cache Tag Helper. Hjälpverktyget för tagg för distribuerad cache använder SQL Server, Rediseller NCache- för att lagra data.

Mer information finns i Distributed Cache Tag Helper i ASP.NET Core.

ResponseCache-attributet

ResponseCacheAttribute Anger de parametrar som krävs för att ange lämpliga rubriker i svarscachelagring.

VaryByQueryKeys varierar det lagrade svaret efter värdena i den angivna listan med frågenycklar. När ett enda värde anges * varierar mellanprogrammet svar efter alla frågesträngsparametrar för begäran.

Cachelagring av svar mellanprogram måste vara aktiverat för att ställa in egenskapen VaryByQueryKeys . Annars genereras ett körningsundundatag. Det finns inget motsvarande HTTP-huvud för egenskapen VaryByQueryKeys . Egenskapen är en HTTP-funktion som hanteras av svars-cachelagring med mellanvara. För att mellanprogrammet ska kunna hantera ett cachelagrat svar måste frågesträngen och frågesträngsvärdet matcha en tidigare begäran. Tänk till exempel på sekvensen med begäranden och resultat som visas i följande tabell.

Den första begäran returneras av servern och cachelagras i mellanprogram. Den andra begäran returneras av mellanprogram eftersom frågesträngen matchar den tidigare begäran. Den tredje begäran finns inte i cacheminnet för mellanprogram eftersom frågesträngsvärdet inte matchar en tidigare begäran.

ResponseCacheAttribute Används för att konfigurera och skapa (via IFilterFactory) en Microsoft.AspNetCore.Mvc.Internal.ResponseCacheFilter. Utför ResponseCacheFilter arbetet med att uppdatera lämpliga HTTP-huvuden och funktioner i svaret. Filtret:

• Tar bort alla befintliga rubriker för Vary, Cache-Controloch Pragma.
• Skriver ut lämpliga rubriker baserat på egenskaperna som anges i ResponseCacheAttribute.
• Uppdaterar HTTP-funktionen för cachelagring av svar, om VaryByQueryKeys är inställd.

Vary

Det här rubriken skrivs bara när egenskapen VaryByHeader har angetts. Egenskapen är inställd på egenskapens Vary värde. Följande exempel använder egenskapen VaryByHeader :

[ResponseCache(VaryByHeader = "User-Agent", Duration = 30)]
public class Cache1Model : PageModel
{

Med hjälp av exempelappen visar du svarshuvudena med webbläsarens nätverksverktyg. Följande svarshuvuden skickas med cache1-sidsvaret:

Cache-Control: public,max-age=30
Vary: User-Agent

NoStore och Location.None

NoStore åsidosätter de flesta av de andra egenskaperna. När den här egenskapen är inställd på trueCache-Control är rubriken inställd på no-store. Om Location är inställt på None:

• Cache-Control är inställt på no-store,no-cache.
• Pragma är inställt på no-cache.

Om NoStore är false och Location är None, Cache-Control, och Pragma är inställda på no-cache.

NoStore är vanligtvis inställt på true för felsidor. Sidan Cache2 i exempelappen genererar svarshuvuden som instruerar klienten att inte lagra svaret.

[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
public class Cache2Model : PageModel
{

Exempelappen returnerar cache2-sidan med följande rubriker:

Cache-Control: no-store,no-cache
Pragma: no-cache

Om du vill tillämpa ResponseCacheAttribute på alla MVC-kontrollanter i appen eller Razor sidsvar, lägger du till den med ett MVC-filter eller Razor sidfilter.

I en MVC-app:

services.AddMvc().AddMvcOptions(options => 
    options.Filters.Add(
        new ResponseCacheAttribute
        {
            NoStore = true, 
            Location = ResponseCacheLocation.None
        }));

En metod som gäller för Razor Pages-appar finns under Att lägga till ResponseCacheAttribute i den globala MVC-filterlistan gäller inte för Razor Pages (dotnet/aspnetcore #18890).

Plats och varaktighet

Om du vill aktivera cachelagring Duration måste du ange ett positivt värde och Location måste vara antingen Any (standardvärdet) eller Client. Ramverket anger header till platsvärdet följt av responsen.

Locations alternativ för Any och Client motsvarar rubrikvärdena Cache-Control med public respektive private. Som angett i avsnittet NoStore och Location.None, när du ställer in Location till None, ställer du in både Cache-Control och Pragma-huvuden till no-cache.

Location.Any (Cache-Control inställt på public) anger att klienten eller någon mellanliggande proxy kan cachelagra värdet, inklusive Mellanprogram för svarscachelagring.

Location.Client (Cache-Control inställt på private) anger att endast klienten kan cachelagrar värdet. Ingen mellanliggande cache ska cachelagra värdet, inklusive Response Caching Middleware.

Cachekontrollhuvuden ger bara vägledning till klienter och mellanliggande proxyservrar när och hur du cachelagrar svar. Det finns ingen garanti för att klienter och proxyservrar kommer att respektera RFC 9111: HTTP-cachelagring. Cachelagring av svar Mellanprogram följer alltid de cachelagringsregler som anges i specifikationen.

I följande exempel visas cache3-sidmodellen från exempelappen och rubrikerna som skapas genom att ange Duration och lämna standardvärdet Location :

[ResponseCache(Duration = 10, Location = ResponseCacheLocation.Any, NoStore = false)]
public class Cache3Model : PageModel
{

Exempelappen returnerar cache3-sidan med följande rubrik:

Cache-Control: public,max-age=10

Cache-profiler

I stället för att duplicera inställningarna för svarscache på många åtgärdsattribut på kontrollernivå kan cacheprofiler konfigureras som alternativ när man konfigurerar MVC/Razor Pages i Startup.ConfigureServices. Värden som finns i en refererad cacheprofil används som standardvärden för ResponseCacheAttribute och åsidosätts av alla egenskaper som anges i attributet.

Konfigurera en cacheprofil. I följande exempel visas en cacheprofil på 30 sekunder i exempelappens Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages();
    services.AddMvc(options =>
    {
        options.CacheProfiles.Add("Default30",
            new CacheProfile()
            {
                Duration = 30
            });
    });
}

Exempelappens Cache4-sidmodell refererar till Default30 cacheprofilen:

[ResponseCache(CacheProfileName = "Default30")]
public class Cache4Model : PageModel
{

ResponseCacheAttribute Kan tillämpas på:

• Razor Sidor: Attributen kan inte tillämpas på hanteringsmetoder.
• MVC-styrenheter.
• MVC-åtgärdsmetoder: Attribut på metodnivå åsidosätter de inställningar som anges i attribut på klassnivå.

Det resulterande huvudet som tillämpas på cache4-sidsvaret från Default30 cacheprofilen:

Cache-Control: public,max-age=30

Ytterligare resurser

• Lagra svar i cacheminnen
• RFC 9111: HTTP-cachelagring (avsnitt 5.2. Cache-Control)
• Cache i minnet i ASP.NET Core
• Distribuerad cachelagring i ASP.NET Core
• Identifiera ändringar med ändringstoken i ASP.NET Core
• Mellanprogram för cachelagring av svar i ASP.NET Core
• Hjälp för cachetaggen i ASP.NET Core MVC
• Tagghjälparen för distribuerad cache i ASP.NET Core