Come configurare la memorizzazione nella cache di Entity Framework?

Introduzione

Nelle applicazioni .NET ad alto numero di transazioni, il database rappresenta spesso il principale collo di bottiglia. Sebbene Entity Framework (EF) Core sia un potente Object-Relational-Mapping (ORM), continua a intercettare il database per ogni singola query, causando colli di bottiglia nelle prestazioni e problemi di scalabilità.

Entity Framework Core Caching risolve questo problema introducendo una cache distribuita in memoria, NCache, tra l'applicazione e il database. Intercettando le query LINQ, fornisce istantaneamente i dati a cui si accede frequentemente dalla cache, riducendo drasticamente i costosi accessi al database.

Punti chiave

• Per impostazione predefinita, Entity Framework Core non memorizza nella cache i risultati delle query. Ciò comporta costosi accessi al database nelle applicazioni ad alta intensità di lettura e rallenta l'applicazione.
• NCache fornisce una cache L2 per EF Core distribuita, che fornisce i risultati delle query LINQ direttamente dalla memoria.
• Memorizzazione nella cache in EF Core con NCache richiede modifiche minime al codice, utilizzando metodi come FromCache() and LoadIntoCache() senza modificare le query.
• I metodi di esecuzione differita sono necessari per gli aggregati per garantire che l'intercettazione della cache funzioni correttamente.
• La coerenza della cache viene preservata automaticamente tramite dipendenze di SQL Server che invalidano i dati memorizzati nella cache quando questi vengono modificati nel database.

Perché usare NCache per EF Core?

• Scalabilità lineare: Consente alla tua applicazione di gestire carichi di transazioni di picco senza dover aggiornare l'hardware del database o senza colli di bottiglia nelle prestazioni.
• Integrazione senza codice: Non è necessario riscrivere SQL complesso; è possibile continuare a utilizzare query LINQ standard in EF con semplici metodi di estensione forniti da NCache.
• Coerenza dei dati: Funzionalità come SqlDependency garantiscono che la cache venga automaticamente invalidata se i dati corrispondenti cambiano nel database, prevenendo il problema dei dati obsoleti.
• Supporto multipiattaforma: NCache è completamente supportato su Windows e Linux, il che lo rende ideale per microservizi .NET 8/10 containerizzati o altre applicazioni server .NET.

Prerequisiti e installazione

Per iniziare, assicurati di avere un NCache cache cluster in esecuzione.

Passaggio 1: installare il pacchetto NuGet

Esegui il seguente comando nella console di Gestione pacchetti. Assicurati di selezionare la versione compatibile con la tua release .NET (ad esempio, .NET 10).

Install-Package EntityFrameworkCore.NCache

Fase 2: Serializzazione

In .NET 8/10, la serializzazione binaria è limitata. Fortunatamente, NCache Supporta la serializzazione JSON pronta all'uso, ideale per le moderne app .NET. Assicurati che le classi delle entità siano pubbliche e abbiano costruttori senza parametri.

Come configurare la memorizzazione nella cache di EF Core con NCache

L'integrazione di NCache con EF Core avviene principalmente all'interno del tuo DbContext. Devi configurare NCache come fornitore di cache durante l'avvio dell'applicazione o la configurazione del contesto.

Modifica del DbContext
Sostituisci il metodo OnConfiguring nel tuo DbContext per connetterti a NCache.

using Alachisoft.NCache.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    private readonly IConfiguration _configuration;

    // Inject configuration via constructor
    public AppDbContext(DbContextOptions<AppDbContext> options, IConfiguration configuration) 
        : base(options)
    {
        _configuration = configuration;
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
	  // 2. Unique Cache ID configured in NCache Manager
        string cacheId = _configuration["NCacheSettings:CacheId"];

        // 3. Target-typed new expression (C# 9+) - Type is inferred from variable
        CacheConnectionOptions ncacheOptions = new()
        {
            RetryInterval = TimeSpan.FromSeconds(2),
            ConnectionRetries = 2
        };

        // 4. Initialize the NCache provider
        // DependencyType.SqlServer ensures cache syncs with SQL DB changes
        NCacheConfiguration.Configure(cacheId, DependencyType.SqlServer, ncacheOptions);

        base.OnConfiguring(optionsBuilder);
    }
}

Strategie di caching e API

NCache estende IQueryable con metodi personalizzati. Ciò consente di memorizzare nella cache i risultati direttamente all'interno della pipeline LINQ.

1. Il modello Cache-Aside (FromCache)

   Questo è il metodo più comune. Controlla prima la cache; se mancano dati, li recupera dal database, memorizza nella cache il risultato e lo restituisce.

   // Standard LINQ query with caching enabled
   var activeCustomers = _context.Customers
       .Where(c => c.IsActive)
       .FromCache(); // Checks cache first, then DB

2. Popolamento della cache con dati di riferimento (LoadIntoCache)

   Utilizzalo per i "Dati di riferimento" (tabelle di consultazione, cataloghi prodotti). Recupera sempre dal database e aggiorna la cache, garantendone l'aggiornamento.

   // Forces a DB trip and updates the cache
   var products = _context.Products
       .LoadIntoCache();

3. Query solo cache per dati di riferimento (FromCacheOnly)

   Questa query interroga solo la cache e non il database. Se mancano dati, restituisce un risultato vuoto o genera un'eccezione (configurabile). Questa è la soluzione ideale per i dati di riferimento che vengono letti frequentemente con letture ultraveloci.

   var cachedOrders = _context.Orders
       .Where(o => o.Region == "US")
       .FromCacheOnly();

4. Esecuzione differita (DeferredCount, DeferredFirst)

   Operatori standard come, .Count() or .FirstOrDefault(), esegui immediatamente, bypassando l'intercettore della cache. NCache fornisce alternative "differite" per ritardare l'esecuzione finché non viene applicata la logica della cache.

   // INCORRECT: Hits DB immediately
   // var count = _context.Customers.Count(); 
   
   // CORRECT: Defers execution so caching can work
   var count = _context.Customers.DeferredCount().FromCache();

Scadenza della cache EF Core e dipendenza SQL

È possibile controllare la scadenza e la sincronizzazione utilizzando la classe CachingOptions.

Politiche di scadenza

È possibile impedire che la cache cresca indefinitamente impostando regole di scadenza in modo che i dati più vecchi vengano automaticamente rimossi dalla cache alla scadenza.

// 1. Target-typed new expression (inferred type)
CachingOptions options = new()
{
    StoreAs = StoreAs.SeperateEntities,
    Priority = CacheItemPriority.High
};

// 2. Setting Expiration (Best Practice: Use UtcNow for distributed systems)
options.SetAbsoluteExpiration(DateTime.UtcNow.AddMinutes(10));

// 3. Executing the query
var topSellers = _context.Sellers.FromCache(options);

Sincronizza la cache con il database

Per garantire che la cache non sia mai obsoleta, abilitare CreateDbDependency. In questo modo viene configurato un watcher sulle righe del server SQL.

var syncOptions = new CachingOptions
{
    CreateDbDependency = true // Auto-remove from cache if SQL row changes
};

var specificOrder = _context.Orders
    .Where(o => o.Id == 10248)
    .FromCache(syncOptions);

Verifica e monitoraggio della cache

• NCache Centro Direzionale: Utilizzare la dashboard visiva basata sul Web per monitorare i "Cache Hit" e i "Cache Miss".
• Registrazione: Puoi abilitare NCache registrazione o ispezionare il tuo SQL Profiler. Se configurato correttamente, l'esecuzione ripetuta di FromCache() le query non dovrebbero mostrare nuove tracce in SQL Profiler.

Conclusione

La configurazione della memorizzazione nella cache di Entity Framework in .NET 8 e 10 è semplice con NCacheAggiungendo un semplice FromCache() Con il metodo di estensione, puoi scaricare le letture dal tuo database e ottenere tempi di risposta inferiori al millisecondo.

Cosa fare dopo?

installare il EntityFrameworkCore.NCache Pacchetto NuGet nel tuo ambiente di staging e misura la differenza di prestazioni sulle query di lettura più pesanti.

• Scaricare NCache
• Leggi NCache Documentazione su EF Core
• Confronto: NCache vs. Redis

_context.GetCache().Remove(entity);