Cache in memoria in ASP.NET Core

Di Rick Anderson, John Luo e Steve Smith

Nota

Questa non è la versione più recente di questo articolo. Per la versione corrente, vedere la versione .NET 11 di questo articolo.

La memorizzazione nella cache può migliorare significativamente le prestazioni e la scalabilità di un'app riducendo il lavoro necessario per generare contenuti. La memorizzazione nella cache funziona meglio con i dati che cambiano raramente ed è costosa da generare. La memorizzazione nella cache crea una copia dei dati che può essere restituita molto più velocemente rispetto all'origine. Le app devono essere scritte e testate in modo da non dipendere mai dai dati memorizzati nella cache.

ASP.NET Core supporta diverse cache. La cache più semplice si basa sull'interfaccia IMemoryCache . IMemoryCache rappresenta una cache archiviata nella memoria del server Web. Le app in esecuzione in una server farm (più server) devono garantire che le sessioni siano permanenti quando si usa la cache in memoria. Le sessioni permanenti assicurano che le richieste provenienti da un client vengano inviate tutte allo stesso server. Ad esempio, un'app Web Azure usa Microsoft Application Request Routing (ARR) per instradare tutte le richieste allo stesso server.

Le sessioni non di tipostick in una Web farm richiedono una cache distribuita per evitare problemi di coerenza della cache. Per alcune app, una cache distribuita può supportare una scalabilità orizzontale più elevata rispetto a una cache in memoria. L'utilizzo di una cache distribuita trasferisce la memoria cache a un processo esterno.

La cache in memoria può memorizzare qualsiasi oggetto. L'interfaccia della cache distribuita è limitata a byte[]. La cache in memoria e quella distribuita archiviano gli elementi della cache come coppie chiave-valore.

Usare System.Runtime.Caching/MemoryCache

System.Runtime.Caching / MemoryCache (pacchetto NuGet) può essere usato con:

  • .NET Standard 2.0 o versione successiva
  • Qualsiasi implementazione .NET destinata a .NET Standard 2.0 o versione successiva (ad esempio ASP.NET Core 3.1 o versione successiva)
  • .NET Framework 4.5 o versione successiva

Microsoft.Extensions.Caching.Memory/IMemoryCache (descritto in questo articolo) è consigliato rispetto a System.Runtime.Caching/MemoryCache perché offre una migliore integrazione con ASP.NET Core. Ad esempio, IMemoryCache funziona in modo nativo con ASP.NET Core dependency injection.

Da utilizzare System.Runtime.Caching/MemoryCache come bridge di compatibilità durante la conversione del codice da ASP.NET 4.x a ASP.NET Core.

Esaminare le linee guida per la memorizzazione nella cache in memoria

Le linee guida seguenti si applicano alla memorizzazione nella cache in memoria:

  • Il codice deve avere sempre un'opzione di fallback per recuperare i dati e non dipendere dalla disponibilità di un valore memorizzato nella cache.

  • La cache usa memoria, che è una risorsa scarsa. Limitare la crescita della cache:

    • Non inserire input esterno nella cache. Ad esempio, l'uso di input arbitrario fornito dall'utente come chiave della cache non è consigliato perché l'input potrebbe utilizzare una quantità imprevedibile di memoria.

    • Utilizzare le scadenze per limitare la crescita della cache.

    • Limitare le dimensioni della cache con SetSize, Size e SizeLimit. Il runtime ASP.NET Core non limita le dimensioni della cache in base alla pressione della memoria. Lo sviluppatore è responsabile della limitazione delle dimensioni della cache.

Creare un'istanza di IMemoryCache

La memorizzazione nella cache in memoria è un servizio a cui fa riferimento un'app usando l'iniezione delle dipendenze.

Warning

Se la stessa cache viene usata da più framework o librerie, si tratta di una cache condivisa . Se si usa una cache di memoria condivisa dall'inserimento delle dipendenze e si usa anche SetSize, Size e SizeLimit per limitare le dimensioni della cache, l'app potrebbe fallire.

Quando viene impostato un limite di dimensioni in una cache, tutte le voci devono specificare una dimensione quando vengono aggiunte. Questo approccio può causare problemi perché gli sviluppatori potrebbero non avere il controllo completo su ciò che usa la cache condivisa.

Per limitare le dimensioni della cache con il metodo SetSize, la proprietà Size o la proprietà SizeLimit, creare un singleton della cache per la memorizzazione nella cache. Per altre informazioni e un esempio, vedere Limitare le dimensioni della cache con SetSize, Size e SizeLimit.

Richiedi l'istanza IMemoryCache nel costruttore:

public class IndexModel : PageModel
{
    private readonly IMemoryCache _memoryCache;

    public IndexModel(IMemoryCache memoryCache) =>
        _memoryCache = memoryCache;

    // ...

Il codice seguente usa il TryGetValue metodo per verificare se un'ora si trova nella cache. Se un tempo non è memorizzato nella cache, viene creata una nuova voce e aggiunta alla cache utilizzando il metodo Set.

public void OnGet()
{
    CurrentDateTime = DateTime.Now;

    if (!_memoryCache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
    {
        cacheValue = CurrentDateTime;

        var cacheEntryOptions = new MemoryCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(3));

        _memoryCache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
    }

    CacheCurrentDateTime = cacheValue;
}

Nel codice precedente, l'entry della cache viene configurata con una scadenza scorrevole di 3 secondi. Se la voce della cache non è accessibile per più di 3 secondi, la voce viene rimossa dalla cache. Ogni volta che si accede alla voce della cache, questa rimane nella cache per altri 3 secondi. La CacheKeys classe fa parte dell'esempio di download.

Vengono visualizzate l'ora corrente e l'ora memorizzata nella cache:

<ul>
    <li>Current Time: @Model.CurrentDateTime</li>
    <li>Cached Time: @Model.CacheCurrentDateTime</li>
</ul>

Il codice seguente utilizza il metodo di Set estensione per memorizzare nella cache i dati per un periodo di tempo relativo senza MemoryCacheEntryOptions:

_memoryCache.Set(CacheKeys.Entry, DateTime.Now, TimeSpan.FromDays(1));

Nel codice precedente, la voce della cache è configurata con una scadenza relativa di un giorno. La voce della cache viene eliminata dalla cache dopo un giorno, anche se si accede alla voce durante il periodo di timeout.

Il codice seguente usa i metodi GetOrCreate e GetOrCreateAsync per memorizzare i dati nella cache.

public void OnGetCacheGetOrCreate()
{
    var cachedValue = _memoryCache.GetOrCreate(
        CacheKeys.Entry,
        cacheEntry =>
        {
            cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
            return DateTime.Now;
        });

    // ...
}

public async Task OnGetCacheGetOrCreateAsync()
{
    var cachedValue = await _memoryCache.GetOrCreateAsync(
        CacheKeys.Entry,
        cacheEntry =>
        {
            cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
            return Task.FromResult(DateTime.Now);
        });

    // ...
}

Il codice seguente chiama il Get metodo per recuperare l'ora memorizzata nella cache:

var cacheEntry = _memoryCache.Get<DateTime?>(CacheKeys.Entry);

Il codice seguente ottiene o crea un elemento memorizzato nella cache con scadenza assoluta:

var cachedValue = _memoryCache.GetOrCreate(
    CacheKeys.Entry,
    cacheEntry =>
    {
        cacheEntry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20);
        return DateTime.Now;
    });

Un set di elementi memorizzato nella cache con solo una scadenza variabile rischia di non scadere mai. Se l'elemento memorizzato nella cache viene eseguito ripetutamente entro l'intervallo di scadenza variabile, l'elemento non scade mai. La combinazione di una scadenza scorrevole con una scadenza assoluta garantisce la scadenza dell'elemento. La scadenza assoluta imposta un limite superiore per quanto tempo l'elemento può essere memorizzato nella cache. Consente comunque la scadenza dell'elemento in precedenza, se l'elemento non viene richiesto entro l'intervallo di scadenza scorrevole. Se l'intervallo di scadenza variabile o il tempo di scadenza assoluto passa, l'elemento viene rimosso dalla cache.

Il codice seguente ottiene o crea un elemento memorizzato nella cache con scadenza variabile e assoluta:

var cachedValue = _memoryCache.GetOrCreate(
    CacheKeys.CallbackEntry,
    cacheEntry =>
    {
        cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
        cacheEntry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20);
        return DateTime.Now;
    });

Il codice precedente garantisce che i dati non siano memorizzati nella cache più a lungo del tempo assoluto.

GetOrCreate, GetOrCreateAsynce Get sono metodi di estensione nella CacheExtensions classe . Questi metodi estendono la capacità di IMemoryCache.

Creare MemoryCacheEntryOptions per un elemento

Nell'esempio seguente viene mostrato come creare MemoryCacheEntryOptions per un'entrata. Il codice completa le attività seguenti:

  • Imposta la priorità della cache su CacheItemPriority.NeverRemove.

  • Imposta un PostEvictionDelegate oggetto da chiamare dopo la rimozione della voce dalla cache. Il callback viene eseguito su un thread diverso dal codice che rimuove l'elemento dalla cache.

public void OnGetCacheRegisterPostEvictionCallback()
{
    var memoryCacheEntryOptions = new MemoryCacheEntryOptions()
        .SetPriority(CacheItemPriority.NeverRemove)
        .RegisterPostEvictionCallback(PostEvictionCallback, _memoryCache);

    _memoryCache.Set(CacheKeys.CallbackEntry, DateTime.Now, memoryCacheEntryOptions);
}

private static void PostEvictionCallback(
    object cacheKey, object? cacheValue, EvictionReason evictionReason, object? state)
{
    if (state is IMemoryCache memoryCache)
    {
        memoryCache.Set(
            CacheKeys.CallbackMessage,
            $"Entry {cacheKey} was evicted: {evictionReason}.");
    }
}

Limitare le dimensioni della cache con SetSize, Size e SizeLimit

Un'istanza MemoryCache può facoltativamente specificare e applicare un limite di dimensioni. Il limite delle dimensioni della cache non ha un'unità di misura definita perché la cache non dispone di un meccanismo per misurare le dimensioni delle voci. Se il limite delle dimensioni della cache è impostato, tutte le voci devono specificare le dimensioni. Il runtime ASP.NET Core non limita le dimensioni della cache in base all'utilizzo eccessivo della memoria. Spetta allo sviluppatore limitare la dimensione della cache. La dimensione specificata è espressa in unità scelte dallo sviluppatore.

Per esempio:

  • Se l'app Web memorizza nella cache principalmente le stringhe, ogni dimensione della voce della cache potrebbe essere la lunghezza della stringa.
  • L'app può specificare la dimensione di ciascuna voce pari a 1 e il limite di grandezza è determinato dal numero di voci.

Se la SizeLimit proprietà non è impostata, la cache aumenta senza limiti. Il runtime ASP.NET Core non taglia la cache quando la memoria di sistema è insufficiente. Le app devono essere progettate per:

  • Limitare la crescita della cache.
  • Chiamare il Compact metodo o Remove quando la memoria disponibile è limitata.

Il codice seguente crea un'istanza a dimensione MemoryCache fissa senza unità di misura accessibile tramite iniezione delle dipendenze:

public class MyMemoryCache
{
    public MemoryCache Cache { get; } = new MemoryCache(
        new MemoryCacheOptions
        {
            SizeLimit = 1024
        });
}

La SizeLimit proprietà non dispone di unità. Le voci memorizzate nella cache devono specificare le dimensioni in qualsiasi unità che considerino più appropriate quando viene impostato il limite di dimensioni della cache. Tutti gli utenti di un'istanza della cache devono utilizzare lo stesso sistema di unità. Una voce non viene memorizzata nella cache se la somma delle dimensioni delle voci memorizzate nella cache supera il valore specificato da SizeLimit. Se non è impostato alcun limite per la dimensione della cache, la dimensione della cache impostata per la voce viene ignorata.

Il codice seguente registra l'istanza MyMemoryCache nel contenitore di iniezione delle dipendenze :

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddSingleton<MyMemoryCache>();

MyMemoryCache viene creata come cache di memoria indipendente per i componenti che conoscono questa cache limitata di dimensioni e sanno come impostare le dimensioni della voce della cache in modo appropriato.

Le dimensioni della voce della cache possono essere impostate usando il SetSize metodo di estensione o la Size proprietà :

if (!_myMemoryCache.Cache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
{
    var cacheEntryOptions = new MemoryCacheEntryOptions()
        .SetSize(1);

    // cacheEntryOptions.Size = 1;

    _myMemoryCache.Cache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
}

Nel codice precedente, le due righe evidenziate ottengono lo stesso risultato dell'impostazione delle dimensioni della voce della cache. Il SetSize metodo viene fornito per praticità durante il concatenamento delle chiamate a new MemoryCacheOptions().

Rimuovere gli elementi della cache con MemoryCache.Compact

Il MemoryCache.Compact metodo tenta di rimuovere la percentuale specificata della cache nell'ordine seguente:

  • Tutti gli elementi scaduti
  • Elementi per priorità, in cui gli elementi con priorità più bassa vengono rimossi per primi
  • Oggetti usati meno di recente
  • Elementi con la scadenza assoluta più vicina
  • Elementi con la scadenza scorrevole più precoce

Gli elementi bloccati con priorità NeverRemove non vengono mai rimossi. Il codice seguente rimuove un elemento della cache e chiama il metodo Compact per rimuovere il 25% delle voci archiviate nella cache.

_myMemoryCache.Cache.Remove(CacheKeys.Entry);
_myMemoryCache.Cache.Compact(.25);

Per ulteriori informazioni, vedere la sorgente compatta su GitHub.

Rimuovere una voce della cache con dipendenze scadute

Per abilitare l'ereditarietà dei token di scadenza e delle impostazioni di scadenza basate sul tempo tra le voci della cache collegate, impostare su TrackLinkedCacheEntriestrue quando si registra la cache in Program.cs. Questa opzione è false per impostazione predefinita a partire da .NET 7:

builder.Services.AddMemoryCache(options =>
{
    options.TrackLinkedCacheEntries = true;
});

Nell'esempio seguente viene illustrato come far scadere una voce della cache se scade una voce dipendente. A CancellationChangeToken viene aggiunto all'elemento memorizzato nella cache. Quando il metodo Cancel viene chiamato sull'oggetto CancellationTokenSource, entrambe le voci della cache vengono rimosse:

public void OnGetCacheCreateDependent()
{
    var cancellationTokenSource = new CancellationTokenSource();

    _memoryCache.Set(
        CacheKeys.DependentCancellationTokenSource,
        cancellationTokenSource);

    using var parentCacheEntry = _memoryCache.CreateEntry(CacheKeys.Parent);

    parentCacheEntry.Value = DateTime.Now;

    _memoryCache.Set(
        CacheKeys.Child,
        DateTime.Now,
        new CancellationChangeToken(cancellationTokenSource.Token));
}

public void OnGetCacheRemoveDependent()
{
    var cancellationTokenSource = _memoryCache.Get<CancellationTokenSource>(
        CacheKeys.DependentCancellationTokenSource);

    cancellationTokenSource?.Cancel();
}

Quando si utilizza l'oggetto CancellationTokenSource, è possibile rimuovere più voci della cache come gruppo. Con il rilevamento delle voci collegate abilitato, la voce padre eredita il token di scadenza dalla voce figlio creata all'interno del relativo using ambito.

Rivedere le note sulla memorizzazione nella cache in memoria

Le note seguenti si applicano alla memorizzazione nella cache in memoria:

  • La scadenza non avviene in background.

    Non esiste un timer che esegue attivamente la scansione della cache alla ricerca di elementi scaduti. Qualsiasi attività nella cache (tramite Get, TryGetValue, Seto Remove) può attivare un'analisi in background per gli elementi scaduti. Un timer impostato sull'oggetto CancellationTokenSource (utilizzando il CancelAfter metodo ) rimuove anche la voce e attiva un'analisi degli elementi scaduti.

    Nell'esempio seguente viene usato il CancellationTokenSource(TimeSpan) costruttore di overload per il token registrato. Quando questo token viene attivato, rimuove immediatamente la voce e attiva i callback di espulsione.

    if (!_memoryCache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
    {
        cacheValue = DateTime.Now;
    
        var cancellationTokenSource = new CancellationTokenSource(
            TimeSpan.FromSeconds(10));
    
        var cacheEntryOptions = new MemoryCacheEntryOptions()
            .AddExpirationToken(
                new CancellationChangeToken(cancellationTokenSource.Token))
            .RegisterPostEvictionCallback((key, value, reason, state) =>
            {
                (state as CancellationTokenSource)?.Dispose();
            }, cancellationTokenSource);
    
        _memoryCache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
    }
    
  • Quando si usa un callback per ripopolare un elemento della cache:

    • È possibile che più richieste rilevino che il valore della chiave memorizzata nella cache è vuoto perché il callback non è terminato.
    • Questo approccio può comportare il ripopolamento di più thread dell'elemento memorizzato nella cache.
  • Quando il rilevamento delle voci collegate è abilitato e una voce della cache (padre) crea un'altra voce (figlio), l'elemento padre eredita i token di scadenza del figlio e le impostazioni di scadenza basate sul tempo. La rimozione o l'aggiornamento manuale dell'elemento figlio non comporta la scadenza dell'elemento padre.

  • Utilizzare la PostEvictionCallbacks proprietà per specificare quali callback devono essere attivati dopo la rimozione di una voce della cache dalla cache.

  • Per la maggior parte delle app, IMemoryCache è abilitato. Ad esempio, chiamare AddMvc, AddControllersWithViews, AddRazorPages, AddMvcCore().AddRazorViewEngine e molti altri metodi Add{Service} nel file Program.cs abilita IMemoryCache.

    Per le app che non chiamano uno dei metodi indicati Add{Service} , potrebbe essere necessario chiamare il AddMemoryCache metodo nel file Program.cs .

  • MemoryCache è thread-safe e può essere usato simultaneamente tra più thread.

  • L'accesso alla Count proprietà è dispendioso a livello di calcolo con concorrenza elevata perché richiede l'aggregazione di elementi tra partizioni interne. Evitare di accedere frequentemente a Count nei percorsi di richiesta sensibili alle prestazioni.

  • GetOrCreate e GetOrCreateAsync non sono atomici. Quando più richieste non trovano la stessa chiave contemporaneamente, ogni richiesta esegue la factory e l'ultimo valore scritto è quello che rimane nella cache. Per un'origine dati costosa, questo può causare un burst di chiamate duplicate. Per eseguire la factory una sola volta per chiave, usare HybridCache, che fornisce protezione contro lo stampede.

  • La cache archivia i riferimenti a oggetti, non copie. Se il codice cambia un oggetto dopo averlo letto dalla cache, ogni chiamante che legge tale voce visualizza la modifica. Memorizzare nella cache oggetti non modificabili o copiare un oggetto prima di modificarlo.

Usare un aggiornamento della cache in background

Usare un servizio in background , ad esempio l'interfaccia IHostedService per aggiornare la cache. Il servizio in background può ricompilare le voci e assegnarle alla cache solo dopo che sono pronte.