Panoramica della memorizzazione nella cache in ASP.NET Core

Di Rick Anderson e Tom Dykstra

Memorizzazione nella cache in memoria

La memorizzazione nella cache in memoria usa la memoria del server per archiviare i dati memorizzati nella cache. Questo tipo di memorizzazione nella cache è adatto per un singolo server o più server che usano l'affinità di sessione. L'affinità di sessione è nota anche come sessioni permanenti. L'affinità di sessione indica che le richieste da un client vengono sempre instradate allo stesso server per l'elaborazione.

Per altre informazioni, vedere Cache in memoria in ASP.NET Core e Risolvere i problemi di affinità di sessione del gateway di app Azure.

Cache distribuita

Usare una cache distribuita per archiviare i dati quando l'app è ospitata in un cloud o in una server farm. La cache viene condivisa tra i server che elaborano le richieste. Un client può inviare una richiesta gestita da qualsiasi server nel gruppo se sono disponibili dati memorizzati nella cache per il client. ASP.NET Core funziona con le cache distribuite di SQL Server, Redis e NCache .

Per altre informazioni, vedere Memorizzazione nella cache distribuita in ASP.NET Core.

HybridCache

L'API HybridCache consente di colmare alcune lacune nelle IDistributedCache API e IMemoryCache . HybridCache è una classe astratta con un'implementazione predefinita che gestisce la maggior parte degli aspetti del salvataggio nella cache e del recupero dalla cache.

Funzionalità

HybridCache include le funzionalità seguenti che le altre API non hanno:

• API unificata per la memorizzazione nella cache in-process e out-of-process.

  HybridCacheè progettato per essere una sostituzione dell'eliminazione per l'uso e IMemoryCache esistente IDistributedCache e offre una semplice API per l'aggiunta di nuovo codice di memorizzazione nella cache. Se l'app ha un'implementazione IDistributedCache , il HybridCache servizio lo usa per la memorizzazione nella cache secondaria. Questa strategia di memorizzazione nella cache a due livelli consente di HybridCache fornire la velocità di una cache in memoria e la durabilità di una cache distribuita o persistente.

• Protezione stampede.

  Lo stampede della cache si verifica quando viene revocata una voce della cache usata di frequente e troppe richieste tentano di ripopolare contemporaneamente la stessa voce della cache. HybridCache combina operazioni simultanee, assicurandosi che tutte le richieste per una determinata risposta attendino che la prima richiesta popola la cache.

• Serializzazione configurabile.

  La serializzazione viene configurata come parte della registrazione del servizio, con supporto per serializzatori specifici del tipo e generalizzati tramite i WithSerializer metodi e WithSerializerFactory concatenati dalla AddHybridCache chiamata. Per impostazione predefinita, il servizio gestisce string e byte[] internamente e usa System.Text.Json per tutto il resto. Può essere configurato per altri tipi di serializzatori, ad esempio protobuf o XML.

Per visualizzare la semplicità relativa dell'API HybridCache , confrontare il codice che lo usa con il codice che usa IDistributedCache. Di seguito è riportato un esempio dell'aspetto dell'uso IDistributedCache :

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)
    { /* ... */ }
}

Questo è un sacco di lavoro per ottenere il giusto ogni volta, inclusi elementi come la serializzazione. Nello scenario di mancata memorizzazione nella cache, è possibile finire con più thread simultanei, ottenere tutti un mancato riscontro nella cache, recuperare tutti i dati sottostanti, serializzarli e tutti inviare tali dati alla cache.

Ecco il codice equivalente usando 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
        );
    }
}

Il codice è più semplice e la libreria fornisce protezione stampede e altre funzionalità che IDistributedCache non lo fanno.

Compatibilità

La HybridCache libreria supporta runtime .NET meno recenti, fino a .NET Framework 4.7.2 e .NET Standard 2.0.

Risorse aggiuntive

Per ulteriori informazioni, vedi le seguenti risorse:

• Libreria HybridCache in ASP.NET Core
• Problema di GitHub dotnet/aspnetcore #54647
• HybridCache codice sorgente

Helper per tag di cache

Memorizzare nella cache il contenuto da una visualizzazione MVC o Razor da una pagina con l'helper tag della cache. L'helper tag cache usa la memorizzazione nella cache in memoria per archiviare i dati.

Per altre informazioni, vedere Helper tag cache in ASP.NET Core MVC.

Helper tag di cache distribuita

Memorizzare nella cache il contenuto da una visualizzazione MVC o Razor da una pagina in scenari cloud o web farm distribuiti con l'helper tag cache distribuita. L'helper tag della cache distribuita usa SQL Server, Redis o NCache per archiviare i dati.

Per altre informazioni, vedere Distributed Cache Tag Helper in ASP.NET Core.

Memorizzazione nella cache delle risposte

Middleware di memorizzazione nella cache della risposta:

• Abilita la memorizzazione nella cache delle risposte del server in base alle intestazioni della cache HTTP. Implementa la semantica di memorizzazione nella cache HTTP standard. Memorizza nella cache le intestazioni della cache HTTP come i proxy.
• In genere non è utile per le app dell'interfaccia utente, ad Razor esempio Pagine, perché i browser impostano in genere intestazioni di richiesta che impediscono la memorizzazione nella cache. La memorizzazione nella cache di output, disponibile in ASP.NET Core 7.0 e versioni successive, offre vantaggi alle app dell'interfaccia utente. Con la memorizzazione nella cache dell'output, la configurazione decide cosa deve essere memorizzato nella cache indipendentemente da intestazioni HTTP.
• Può essere utile per le richieste API GET o HEAD pubbliche dai client in cui vengono soddisfatte le condizioni per la memorizzazione nella cache .

Per testare la memorizzazione nella cache delle risposte, usare Fiddler o un altro strumento in grado di impostare in modo esplicito le intestazioni della richiesta. L'impostazione esplicita delle intestazioni è preferibile per il test della memorizzazione nella cache. Per ulteriori informazioni, vedere Risoluzione dei problemi.

Caching dell'output

Il middleware di memorizzazione nella cache dell'output consente la memorizzazione nella cache delle risposte HTTP. La memorizzazione nella cache dell'output differisce dalla memorizzazione nella cache delle risposte nei modi seguenti:

• Il comportamento di memorizzazione nella cache è configurabile nel server.

  Il comportamento di memorizzazione nella cache delle risposte è definito dalle intestazioni HTTP. Ad esempio, quando si visita un sito Web con Chrome o Edge, il browser invia automaticamente un'intestazione Cache-control: max-age=0 . Questa intestazione disabilita efficacemente la memorizzazione nella cache delle risposte, poiché il server segue le istruzioni fornite dal client. Viene restituita una nuova risposta per ogni richiesta, anche se il server ha una risposta aggiornata memorizzata nella cache. Con la memorizzazione nella cache dell'output, il client non esegue l'override del comportamento di memorizzazione nella cache configurato nel server.

• Il supporto di archiviazione della cache è estendibile.

  La memoria viene usata per impostazione predefinita. La memorizzazione nella cache delle risposte è limitata alla memoria.

• È possibile invalidare le voci della cache selezionate a livello di codice.

  La dipendenza della memorizzazione nella cache delle risposte nelle intestazioni HTTP lascia poche opzioni per invalidare le voci della cache.

• Il blocco delle risorse riduce il rischio di cache stampede e fulmine.

  Lo stampede della cache si verifica quando viene revocata una voce della cache usata di frequente e troppe richieste tentano di ripopolare contemporaneamente la stessa voce della cache. Thundering herd è simile: un burst di richieste per la stessa risposta che non è già in una voce della cache. Il blocco delle risorse garantisce che tutte le richieste per una determinata risposta attendino che la prima richiesta popola la cache. La memorizzazione nella cache delle risposte non ha una funzionalità di blocco delle risorse.

• La riconvalida della cache riduce al minimo l'utilizzo della larghezza di banda.

  La riconvalida della cache indica che il server può restituire un 304 Not Modified codice di stato HTTP anziché un corpo della risposta memorizzato nella cache. Questo codice di stato informa il client che la risposta alla richiesta rimane invariata rispetto a quella ricevuta in precedenza. La memorizzazione nella cache delle risposte non esegue la riconvalida della cache.