Gestione della cache dal contesto di EF Core
NCacheI metodi di estensione EF Core di consentono inoltre flessibilità quando si gestiscono le entità direttamente tramite la cache. Queste API non coinvolgono l'origine dati, pertanto i dati vengono immessi e rimossi direttamente dalla cache senza modificare l'origine dati. Tali API sono utili per i dati che non devono essere modificati frequentemente.
Note:
Questa funzionalità è disponibile anche in NCache Professional.
Utilizzare NCache Le API EF Core includono gli spazi dei nomi seguenti nell'applicazione:
NCache fornisce le seguenti API per scopi di memorizzazione nella cache:
Contesto EF Core: Ottieni istanza cache
L'handle della cache si ottiene tramite il Ottieni cache, NCache Metodo di estensione EF Core sull'estensione dell'applicazione DbContext
classe.
public partial class NorthwindContext : DbContext
{
// Class configures cache with NCacheConfiguration.Configure() method
}
Le chiamate API solo cache vengono effettuate tramite Cache
involucro restituito quando il Ottieni cache viene chiamato il metodo. Il wrapper della cache è associato al contesto in uso. Le entità e le rispettive richieste vengono verificate per la loro tipologia prima che vengano richiamate le operazioni necessarie. Tale verifica avviene con l'ausilio del contesto in oggetto che viene inizializzato quando il Ottieni cache viene effettuata la chiamata. Pertanto, per eseguire correttamente le richieste, il contesto deve essere attivo (non eliminato) quando vengono effettuate le richieste. In caso contrario, verrà lanciato System.ObjectDisposedException
.
Pertanto, nel codice, si consiglia di eseguire operazioni di sola cache all'interno del contesto:
Consigli
Se la cache non viene inizializzata, genera un'eccezione e tutte le operazioni che devono essere eseguite ulteriormente falliranno fino all'inizializzazione della cache.
using (var context = new NorthwindContext())
{
Cache cache = context.GetCache(); // get NCache instance
// Perform cache only operations
}
inserire
Il inserire Il metodo aggiunge l'entità direttamente alla cache senza alcuna dipendenza dal database. Potresti memorizzare un nuovo cliente nel database e aver già recuperato tutti i clienti aggiunti in precedenza nella cache. Invece di eseguire successivamente una query LINQ per recuperare il nuovo cliente dall'origine dati nella cache, puoi semplicemente chiamare inserire subito dopo che il cliente è stato aggiunto al database (when SaveChanges
viene chiamato) con la stessa istanza dell'entità utilizzata per l'inserimento nel database. Ciò consente di risparmiare il costo di un viaggio nel database per un'entità.
Le entità possono essere memorizzate nella cache con quanto segue Opzioni di memorizzazione nella cache:
QueryIdentifier
Priority
AbsoluteExpirationTime
SlidingExpirationTime
Consigli
- Il valore per
StoreAs
isSeparateEntities
, poiché le entità vengono inserite nella cache come entità separate tramite questa API. - La dipendenza del database non può essere iniettata tramite questa API perché non ci sono query effettuate tramite la cache inserire. quindi, il CreaDbDependency proprietà in Opzioni di memorizzazione nella cache viene ignorato all'interno di questa chiamata.
Il Insert
il metodo si comporta come segue:
Caso | Comportamento |
---|---|
Entità non esistente nella cache | Aggiunge entità nella cache |
Entità esistente nella cache | Aggiorna l'entità nella cache |
inserire restituisce una chiave di cache che viene generata internamente per ogni entità archiviata nella cache. Questa chiave di cache può essere salvata per essere utilizzata successivamente a scopo di verifica o per rimuovere l'entità della cache.
Esempi
- L'esempio seguente inserisce a Entità Cliente nella cache con l'identificatore della query Entità Cliente e la
Default
priorità.
using (var database = new NorthwindContext())
{
var cust = new Customers
{
CustomerId = "HANIH",
ContactName = "Hanih Moos",
ContactTitle = "Sales Representative",
CompanyName = "Blauer See Delikatessen"
};
var options = new CachingOptions
{
QueryIdentifier = new Tag("CustomerEntity"),
Priority = Runtime.CacheItemPriority.Default
};
Cache cache = database.GetCache(); // get NCache instance
cache.Insert(cust, out string cacheKey, options);
string key = cacheKey; // can be saved for future use such as removing cache
}
- Questo esempio memorizza nella cache la stessa entità inserita nel database:
using (var database = new NorthwindContext())
{
// Customer entity to be cached and stored to database
var customerEntity = new Customers
{
CustomerId = "HANIH",
ContactName = "Hanih Moos",
ContactTitle = "Sales Representative ",
CompanyName = "Blauer See Delikatessen"
};
// Add customer entity to database
database.Customers.Add(customerEntity);
database.SaveChanges();
// Caching options for cache
var options = new CachingOptions
{
QueryIdentifier = new Tag("CustomerEntity"),
Priority = Runtime.CacheItemPriority.Default,
};
// Add customer entity to cache
Cache cache = database.GetCache();
cache.Insert(cust, out string cacheKey, options);
string key = cacheKey; // can be saved for future use such as removing cache
}
Rimuovere
Il Rimuovere Il metodo rimuove le entità dalla cache, senza eliminarle dal database. Ciò è utile se hai apportato alcune modifiche temporanee alle entità memorizzate nella cache o se le entità potrebbero essere obsolete. La rimozione delle entità dalla cache consente di caricare nuovi dati da un'origine dati, tramite il file FromCache
or LoadIntoCache
metodi.
Questa API ha due sovraccarichi, uno che accetta un'entità, mentre l'altro accetta la chiave di cache corrispondente all'entità. Questa chiave viene restituita durante il file Insert/FromCache/LoadIntoCache
chiama quando l'entità viene aggiunta alla cache e può essere salvata.
public void Remove(object entity);
public void Remove(string cacheKey);
Esempi
- L'esempio seguente rimuove l'entità della cache in base all'entità fornita. Se esiste nella cache, verrà rimosso.
using (var database = new NorthwindContext())
{
var cust = new Customers
{
CustomerId = "HANIH",
ContactName = "Hanih Moos",
ContactTitle = "Sales Representative",
CompanyName = "Blauer See Delikatessen"
};
ICache cache = database.GetCache();
cache.Remove(cust);
}
- L'esempio seguente accetta la chiave della cache come argomento. Se nella cache esiste un'entità rispetto alla chiave, verrà rimossa dalla cache.
using (var database = new NorthwindContext())
{
Cache cache = database.GetCache();
cache.Remove(cacheKey); // cacheKey saved during Insert()/FromCache()/LoadIntoCache() calls
}
RemoveByQueryIdentifier
Il RemoveByQueryIdentifier il metodo rimuove tutte le entità dalla cache in base a quanto specificato QueryIdentifier
in Opzioni di memorizzazione nella cache (quando si inserisce nella cache). Se esistono entità con l'identificatore, tutte le entità associate vengono rimosse dalla cache ma non dall'origine dati effettiva.
using (var database = new NorthwindContext())
{
var options = new CachingOptions
{
QueryIdentifier = new Tag("CustomerEntity"),
};
Cache cache = database.GetCache(); // get NCache instance
cache.RemoveByQueryIdentifier(options.QueryIdentifier);
}
Vedere anche
.NETTO: Alachisoft.NCache.EntityFrameworkCore ed Alachisoft.NCache.Memorizzazione.della.cache spazi dei nomi.