Översikt över cachelagring i ASP.NET Core

Av Rick Anderson och Tom Dykstra

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 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, Redisoch NCache distribuerade cacheminnen.

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

HybridCache

DET HybridCache API:et överbryggar vissa luckor i api:erna för IDistributedCache och IMemoryCache. HybridCache är en abstrakt klass med en standardimplementering som hanterar de flesta aspekter av att spara till cacheminnet och hämta från cacheminnet.

Funktioner

HybridCache har följande funktioner som de andra API:erna inte har:

• Ett enhetligt API för både processbaserad och utanför-process cachelagring.

  HybridCache är designat som en direkt ersättning för befintlig användning av IDistributedCache och IMemoryCache, och det erbjuder ett enkelt API för att lägga till ny cachelagringskod. Om appen har en IDistributedCache implementering använder HybridCache-tjänsten den för sekundär cachelagring. Med den här cachelagringsstrategin på två nivåer kan HybridCache tillhandahålla hastigheten för en minnesintern cache och hållbarheten hos en distribuerad eller beständig cache.

• Stampedeskydd.

  Cache stampede inträffar när ett ofta använt cacheobjekt tas bort och för många begäranden försöker fylla på samma cacheobjekt samtidigt. HybridCache kombinerar samtidiga åtgärder, vilket säkerställer att alla begäranden för ett givet svar väntar på att den första begäran ska fylla i cacheminnet.

• Konfigurerbar serialisering.

  Serialisering konfigureras som en del av tjänsteregistreringen, med stöd för typspecifika och generaliserade serialiserare via metoderna WithSerializer och WithSerializerFactory, som är kedjade från AddHybridCache-anropet. Som standard hanterar tjänsten string och byte[] internt och använder System.Text.Json för allt annat. Den kan konfigureras för andra typer av serialiserare, till exempel protobuf eller XML.

Om du vill se den relativa enkelheten i HybridCache-API:et jämför du koden som använder den till kod som använder IDistributedCache. Här är ett exempel på hur användning av IDistributedCache ser ut:

public class SomeService(IDistributedCache cache)
{
    public async Task<SomeInformation> GetSomeInformationAsync
        (string name, int id, CancellationToken token = default)
    {
        var key = $"someinfo:{name}:{id}"; // Unique key for this combination.
        var bytes = await cache.GetAsync(key, token); // Try to get from cache.
        SomeInformation info;
        if (bytes is null)
        {
            // Cache miss; get the data from the real source.
            info = await SomeExpensiveOperationAsync(name, id, token);

            // Serialize and cache it.
            bytes = SomeSerializer.Serialize(info);
            await cache.SetAsync(key, bytes, token);
        }
        else
        {
            // Cache hit; deserialize it.
            info = SomeSerializer.Deserialize<SomeInformation>(bytes);
        }
        return info;
    }

    // This is the work we're trying to cache.
    private async Task<SomeInformation> SomeExpensiveOperationAsync(string name, int id,
        CancellationToken token = default)
    { /* ... */ }
}

Det är mycket arbete att få rätt varje gång, inklusive saker som serialisering. Och i scenariot "cachemiss" kan du få flera samtidiga trådar, alla får en cachemiss, alla hämtar underliggande data, alla serialiserar dem och alla skickar dessa data till cachen.

Här är motsvarande kod med hjälp av HybridCache:

public class SomeService(HybridCache cache)
{
    public async Task<SomeInformation> GetSomeInformationAsync
        (string name, int id, CancellationToken token = default)
    {
        return await cache.GetOrCreateAsync(
            $"someinfo:{name}:{id}", // Unique key for this entry.
            async cancel => await SomeExpensiveOperationAsync(name, id, cancel),
            token: token
        );
    }
}

Koden är enklare och biblioteket ger stampede-skydd och andra funktioner som IDistributedCache inte gör.

Kompatibilitet

HybridCache-biblioteket stöder äldre .NET-körningar, ned till .NET Framework 4.7.2 och .NET Standard 2.0.

Ytterligare resurser

Mer information finns i följande resurser:

• HybridCache-bibliotek i ASP.NET Core
• API-förslag för hybridcache (dotnet/aspnetcore #54647)
• HybridCache källkod

Cachelagring av svar

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 finns i ASP.NET Core 7.0 och 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.

För mer information, se Cachning av svar i ASP.NET Core.

Cachelagring av utdata

Mellanprogrammet för cachelagring av utdata möjliggör cachelagring av HTTP-svar. Cachelagring av utdata skiljer sig från cachelagring av svar på följande sätt:

• Cachelagringsbeteendet kan konfigureras på servern.

  Beteendet för cachelagring av svar definieras av HTTP-huvuden. När du till exempel besöker en webbplats med Chrome eller Edge skickar webbläsaren automatiskt en Cache-control: max-age=0 rubrik. Denna header förhindrar effektivt cachelagring av svaren eftersom servern följer de instruktioner som ges av klienten. Ett nytt svar returneras för varje begäran, även om servern har ett nytt cachelagrat svar. Med cachelagring av utdata åsidosätter klienten inte det cachelagringsbeteende som du konfigurerar på servern.

• Cachelagringsmediet är utökningsbart.

  Minnet används som standard. Cachelagring av svar är begränsad till minne.

• Du kan programmatiskt ogiltigförklara markerade cacheposter.

  Svarscachelagringens beroende av HTTP-huvuden ger dig några alternativ för att ogiltigförklara cacheposter.

• Resurslåsning minskar risken för cachestämpling och dundrande hjord.

  Cache stampede inträffar när en cachepost som används ofta återkallas och för många begäranden försöker fylla i samma cachepost på samma gång. Thundering- är liknande: en uppsättning begäranden om samma svar som inte redan finns i en cachepost. Resurslåsning säkerställer att alla begäranden för ett givet svar väntar på att den första begäran ska fylla i cacheminnet. Svarscachelagring har ingen funktion för resurslåsning.

• Cacheåtervalidering minimerar bandbreddsanvändningen.

  cachevalidering innebär att servern kan returnera en 304 Not Modified HTTP-statuskod i stället för ett cachelagrat svarsinnehåll. Den här statuskoden informerar klienten om att svaret på begäran är oförändrat från det som togs emot tidigare. Cachelagring av svar gör inte cachevalidering.

Mer information finns i Mellanprogram för cachelagring av utdata 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.