C# Academy · Lezione

Astrazione IDistributedCache

Memorizzi i dati nella cache su più server.

Astrazione IDistributedCache è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Perché usare una cache distribuita?

Una cache in memoria risiede all'interno di un singolo processo, quindi viene persa al riavvio e non è condivisa tra i server. Una cache distribuita risiede in un archivio esterno, come Redis, che ogni istanza dell'applicazione può leggere e aggiornare, rendendo la memorizzazione nella cache coerente in una distribuzione scalata orizzontalmente.

L'interfaccia IDistributedCache

ASP.NET Core astrae la memorizzazione nella cache distribuita tramite IDistributedCache in Microsoft.Extensions.Caching.Distributed. Il codice dipende da questa interfaccia, non direttamente da Redis, quindi è possibile sostituire l'implementazione.

public interface IDistributedCache
{
    byte[] Get(string key);
    Task<byte[]> GetAsync(string key, CancellationToken token = default);
    void Set(string key, byte[] value, DistributedCacheEntryOptions options);
    void Remove(string key);
    void Refresh(string key);
}

Memorizza byte

Noti che la cache memorizza byte[]. Per memorizzare stringhe o oggetti nella cache, è prima necessario serializzarli. Per il caso comune sono disponibili pratici metodi di estensione per le stringhe.

using Microsoft.Extensions.Caching.Distributed;

await cache.SetStringAsync("greeting", "Hello, world");
string value = await cache.GetStringAsync("greeting");

Iniezione della cache

Richieda IDistributedCache tramite l'iniezione nel costruttore, come per qualsiasi altro servizio.

public class WeatherService
{
    private readonly IDistributedCache _cache;
    public WeatherService(IDistributedCache cache)
    {
        _cache = cache;
    }
}

Lettura dalla cache

GetStringAsync restituisce null quando la chiave non è presente o è scaduta. Gestisca sempre il caso di mancato riscontro nella cache.

string cached = await _cache.GetStringAsync("forecast:istanbul");
if (cached is null)
{
    // cache miss: load from source
}

Scrittura nella cache

SetStringAsync memorizza un valore con opzioni di scadenza facoltative, trattate in una lezione successiva.

await _cache.SetStringAsync(
    "forecast:istanbul",
    "22C sunny",
    new DistributedCacheEntryOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
    });

Rimozione e aggiornamento

RemoveAsync rimuove una chiave, ad esempio quando cambiano i dati sottostanti. RefreshAsync reimposta una scadenza scorrevole senza modificare il valore.

await _cache.RemoveAsync("forecast:istanbul");
await _cache.RefreshAsync("session:abc123");

L'implementazione in memoria

Per lo sviluppo o i test, registri la cache distribuita in memoria. Implementa la stessa interfaccia, quindi il codice rimane identico, ma i dati non vengono effettivamente condivisi tra processi.

builder.Services.AddDistributedMemoryCache();

Codice indipendente dal provider

Poiché il codice dipende solo da IDistributedCache, passare dal provider in memoria a Redis, o a SQL Server, richiede una modifica di una sola riga nella registrazione e nessuna modifica al codice dei servizi.

Convenzioni per i nomi delle chiavi

Utilizzi chiavi strutturate e organizzate per namespace, come entity:id:field, ad esempio user:42:profile. Convenzioni chiare evitano collisioni e rendono prevedibile l'invalidazione della cache.

string key = $"user:{userId}:profile";

Quando non utilizzare la cache

Memorizzi nella cache i dati letti frequentemente e modificati raramente. I dati altamente volatili o sensibili e specifici dell'utente potrebbero non essere adatti, e i rischi legati a dati obsoleti devono sempre essere valutati rispetto ai vantaggi in termini di prestazioni.

Verifica rapida

Verifichi l'astrazione IDistributedCache.

Riepilogo

IDistributedCache astrae una cache esterna e condivisa, in modo che ogni istanza dell'applicazione visualizzi gli stessi dati. Memorizza byte[] e offre GetStringAsync/SetStringAsync per le stringhe, oltre a RemoveAsync e RefreshAsync. Dipendere dall'interfaccia mantiene il codice indipendente dal provider e consente di passare da AddDistributedMemoryCache a Redis con una sola riga. Utilizzi chiavi con nomi organizzati per namespace e facilmente comprensibili.

Domande Frequenti

La lezione «Astrazione IDistributedCache» è gratuita?

Sì — il testo completo di «Astrazione IDistributedCache» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Astrazione IDistributedCache»?

Memorizzi i dati nella cache su più server. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Astrazione IDistributedCache»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C# Academy