Översikt över cachelagring 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 som använder 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 när 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.

HybridCache

API HybridCache bygger broar mellan API:erna 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 av HybridCache

HybridCache innehåller följande funktioner som inte är tillgängliga med andra API:er:

• 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 typerna string och byte[] internt och använder det System.Text.Json namnområdet för allt annat. HybridCache 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)
    { /* ... */ }
}

Koden visar en betydande mängd arbete för att få rätt varje gång, inklusive saker som serialisering. Även i scenariot "cache miss" kan du få flera samtidiga trådar. Dessa trådar kan alla få en cachemiss, alla hämtar underliggande data, alla serialiserar dem och alla skickar data till cachen.

Här är motsvarande kod som använder API:et 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 inte är tillgängliga med IDistributedCache gränssnittet.

Kompatibilitet

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

Mer information

Mer information finns i följande resurser:

• HybridCache-bibliotek i ASP.NET Core
• Hybrid Cache API-förslag (GitHub dotnet/aspnetcore-problem #54647)
• HybridCache källkod

Cachelagring av svar

Mellanprogrammet för cachelagring av svar möjliggör cachelagring av serversvar baserat på HTTP-Cache-Control-huvuden.

• Cachelagringsbeteende implementerar standard-HTTP-cachelagringssemantik.

• Cachelagring baseras på HTTP-cachehuvuden som liknar den metod som används av proxyservrar.

• Den här typen av cachelagring är användbar för offentliga GET- eller HEAD API-begäranden från klienter där villkoren för cachelagring är uppfyllda.

• För användargränssnittsappar som Razor Pages är cachelagring av svar vanligtvis inte fördelaktigt. Webbläsare anger ofta begärandehuvuden som förhindrar cachelagring.

  Utdata-caching (finns i .NET 7 och senare) är en bättre metod för UI-appar. I det här scenariot avgör konfigurationen vad som ska cachelagras oberoende av HTTP-huvuden.

Om du vill testa cachelagring av svar använder du Fiddler eller något annat verktyg som uttryckligen kan ange begärandehuvuden. Att ange rubriker uttryckligen är att föredra för testning av cachelagring. För mer information, se Felsökning av mellanprogram för cachelagring av svar>.

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:

• Cachelagringsbeteende kan konfigureras på servern.

  Beteendet för cachelagring av svar definieras med HTTP-huvuden. När du till exempel bläddrar på en webbplats med Chrome eller Microsoft Edge skickar webbläsaren automatiskt en Cache-control: max-age=0-rubrik. Denna header avaktiverar effektivt cachelagring av svar eftersom servern följer de anvisningar som tillhandahålls 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 inte klienten 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.

  Cachelagring av svar är beroende av HTTP-rubriker, vilket ger få alternativ för att ogiltigförklara cacheposter.

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

  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. 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.

  Cacheåtervalidering innebär att servern kan returnera en HTTP-statuskod med 304 som inte har ändrats i stället för en cachelagrad svarstext. 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.

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, Redis, Postgres och distribuerade NCache-cacheminnen .

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

HybridCache

API HybridCache överbryggar luckor i API:erna 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 för HybridCache

HybridCache innehåller följande funktioner som inte är tillgängliga med andra API:er:

• 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[]-typer internt och använder System.Text.Json-namnområdet för allt annat. HybridCache 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)
    { /* ... */ }
}

Koden visar en betydande mängd arbete för att få rätt varje gång, inklusive saker som serialisering. Även i scenariot med "cache-miss" kan du få flera samtidiga trådar. Dessa trådar kan alla få en cachemiss, alla hämtar underliggande data, alla serialiserar dem och alla skickar data till cachen.

Här är motsvarande kod som använder API:et 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 inte är tillgängliga med IDistributedCache gränssnittet.

Kompatibilitet

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

Mer information

Mer information finns i följande resurser:

• HybridCache-bibliotek i ASP.NET Core
• Hybrid Cache API-förslag (GitHub dotnet/aspnetcore-problem #54647)
• HybridCache källkod

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.

Cachelagring av svar

Mellanprogrammet för cachelagring av svar möjliggör cachelagring av serversvar baserat på HTTP-Cache-Control-huvuden.

• Cachelagringsbeteende implementerar standard-HTTP-cachelagringssemantik.

• Cachelagring baseras på HTTP-cachehuvuden som liknar den metod som används av proxyservrar.

• Den här typen av cachelagring är användbar för offentliga GET- eller HEAD API-begäranden från klienter där villkoren för cachelagring är uppfyllda.

• För användargränssnittsappar som Razor Pages är cachelagring av svar vanligtvis inte fördelaktigt. Webbläsare anger ofta begärandehuvuden som förhindrar cachelagring.

  Utdata-caching (finns i .NET 7 och senare) är en bättre metod för UI-appar. I det här scenariot avgör konfigurationen vad som ska cachelagras oberoende av HTTP-huvuden.

Om du vill testa cachelagring av svar använder du Fiddler eller något annat verktyg som uttryckligen kan ange begärandehuvuden. Att ange rubriker uttryckligen är att föredra för testning av cachelagring. För mer information, se Felsökning av mellanprogram för cachelagring av svar>.

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 ett ofta använt cacheobjekt tas bort och för många begäranden försöker fylla på samma cacheobjekt samtidigt. 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.

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, Redis, Postgres och distribuerade NCache-cacheminnen .

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

HybridCache

API HybridCache överbryggar luckor i API:erna 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 för HybridCache

HybridCache innehåller följande funktioner som inte är tillgängliga med andra API:er:

• 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[]-typer internt och använder System.Text.Json-namnområdet för allt annat. HybridCache 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)
    { /* ... */ }
}

Koden visar en betydande mängd arbete för att få rätt varje gång, inklusive saker som serialisering. Även i scenariot med "cache-miss" kan du få flera samtidiga trådar. Dessa trådar kan alla få en cachemiss, alla hämtar underliggande data, alla serialiserar dem och alla skickar data till cachen.

Här är motsvarande kod som använder API:et 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 inte är tillgängliga med IDistributedCache gränssnittet.

Kompatibilitet

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

Mer information

Mer information finns i följande resurser:

• HybridCache-bibliotek i ASP.NET Core
• Hybrid Cache API-förslag (GitHub dotnet/aspnetcore-problem #54647)
• HybridCache källkod

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.

Cachelagring av svar

Mellanprogrammet för cachelagring av svar möjliggör cachelagring av serversvar baserat på HTTP-Cache-Control-huvuden.

• Cachelagringsbeteende implementerar standard-HTTP-cachelagringssemantik.

• Cachelagring baseras på HTTP-cachehuvuden som liknar den metod som används av proxyservrar.

• Den här typen av cachelagring är användbar för offentliga GET- eller HEAD API-begäranden från klienter där villkoren för cachelagring är uppfyllda.

• För användargränssnittsappar som Razor Pages är cachelagring av svar vanligtvis inte fördelaktigt. Webbläsare anger ofta begärandehuvuden som förhindrar cachelagring.

  Utdata-caching (finns i .NET 7 och senare) är en bättre metod för UI-appar. I det här scenariot avgör konfigurationen vad som ska cachelagras oberoende av HTTP-huvuden.

Om du vill testa cachelagring av svar använder du Fiddler eller något annat verktyg som uttryckligen kan ange begärandehuvuden. Att ange rubriker uttryckligen är att föredra för testning av cachelagring. För mer information, se Felsökning av mellanprogram för cachelagring av svar>.

Cachelagring av utdata

Cachelagring av utdata är tillgängligt i .NET 7 eller senare.