Dall'archivio script > ASP.NET Core

Utilizzare Hybrid Cache in .NET 9

di Morgan PizziniMorgan Pizzini, in ASP.NET Core,

Il caching distribuito è una tecnica essenziale nello sviluppo di applicazioni moderne per migliorare le prestazioni e ridurre il carico sui database o servizi. Con l'introduzione di .NET 9, Microsoft ha apportato miglioramenti significativi alla gestione della cache, introducendo il concetto di Hybrid Cache.

Prima di .NET 9, il caching distribuito veniva implementato utilizzando IDistributedCache, un'interfaccia che consente di memorizzare i dati in sistemi esterni come Redis. Il codice per recuperare un elemento può rassomigliare al seguente:

public class SomeService
{
    private readonly IDistributedCache _cache;

    public SomeService(IDistributedCache cache)
    {
        _cache = cache;
    }

    public async Task<SomeInfo> GetSomeInfoAsync(string name, int id, CancellationToken token = default)
    {
        var key = $"{name}-{id}"; // composizione della chiave
        var bytes = await _cache.GetAsync(key, token); // interrogazione della cache
        SomeInfo info;

        if (bytes == null)
        {
            // esecuzione fallback in caso non esista l'elemento
            info = await DataSource.GetDataAsync(name, id, token);

            // serializzazione ed inserimento
            bytes = Serializer.Serialize(info);
            await _cache.SetAsync(key, bytes, token);
        }
        else
        {
            // Elemento trovato, deserializzazione
            info = Serializer.Deserialize<SomeInfo>(bytes);
        }

        return info;
    }
}

Come notiamo questo metodo ha vari svantaggi:

  • Necessità di serializzare e deserializzare manualmente i dati.
  • Possibili ritardi nelle letture, poiché essendo una cache distribuita richiede operazioni di rete.
  • Aumento del carico sulle infrastrutture di caching distribuite.

Con .NET 9, viene introdotto il concetto di Hybrid Cache, che combina i vantaggi del caching in memoria con quelli del caching distribuito, andando a rimuovere tutti gli svantaggi appena elencati.

Il codice convertito di presenta come segue:

public class SomeService
{
    private readonly HybridCache _cache;

    public SomeService(HybridCache cache)
    {
        _cache = cache;
    }

    public async Task<SomeInfo> GetSomeInfoAsync(string name, int id, CancellationToken token = default)
    {
        return await _cache.GetOrCreateAsync(
            $"{name}-{id}", // composizione della chiave
            async cancel => await DataSource.GetDataAsync(name, id, cancel), // fallback
            token: token);
    }
}

La differenza è sostanziale: la serializzazione viene gestita internamente, i dati vengono cercati prima nella memoria locale e, solo se non trovati, viene effettuata una richiesta alla cache distribuita, riducendo di conseguenza anche il carico sul servizio esterno.

Commenti

Visualizza/aggiungi commenti

| Condividi su: Twitter, Facebook, LinkedIn
Aggiorna

Per inserire un commento, devi avere un account.

Fai il login e torna a questa pagina, oppure registrati alla nostra community.

Approfondimenti

I più letti di oggi