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 ulteriori informazioni, vedere Cache in memoria in ASP.NET Core e Risolvere i problemi di affinità di sessione di Application Gateway di 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:

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

  HybridCache è progettato per essere una sostituzione diretta dell'uso esistente di IDistributedCache e IMemoryCache, 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 dalla fuga precipitosa.

  Cache stampede 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 metodi WithSerializer e WithSerializerFactory concatenati alla chiamata AddHybridCache. 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 richiede molto lavoro per farlo correttamente ogni volta, inclusi elementi come la serializzazione. Nello scenario di mancato riscontro nella cache, è possibile che più thread simultanei subiscano un miss della cache, recuperino i dati sottostanti, li serializzino e inviino 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 da sovraccarico e altre funzionalità che IDistributedCache non offre.

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
• Proposta di API per cache ibrido (dotnet/aspnetcore #54647)
• HybridCache codice sorgente

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 le semantiche standard di caching HTTP. Cache basate su intestazioni della cache HTTP come fanno 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 .NET 7 o versione successiva, offre vantaggi alle app dell'interfaccia utente. Con la memorizzazione nella cache dell'output, la configurazione decide cosa deve essere memorizzato nella cache indipendentemente dalle 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.

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

Caching dell'output

Il middleware 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 cache dell'output, il client non modifica il comportamento di memorizzazione nella cache che hai configurato sul 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 programmaticamente le voci della cache selezionate.

  La dipendenza del caching delle risposte dalle intestazioni HTTP lascia poche opzioni per invalidare le voci della cache.

• Il blocco delle risorse riduce il rischio della tempesta nella cache e del problema del branco rumoroso.

  Cache stampede 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'esplosione di richieste della 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.

Per ulteriori informazioni, consulta il middleware di caching dell'output in ASP.NET Core.

Helper per tag di cache

Memorizzare nella cache il contenuto di una visualizzazione MVC o di una pagina con il Tag Helper della cache. Il Cache Tag Helper utilizza la cache in memoria per archiviare i dati.

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

Helper tag di cache distribuita

Memorizza nella cache il contenuto da una vista MVC o dalla pagina Razor in scenari di cloud distribuito o web farm con il Tag Helper della 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.