Metodi di estensione di EF Core
NCache fornisce metodi di estensione sincroni e asincroni per la memorizzazione nella cache delle query in EF Core. Le API di sincronizzazione sono metodi di estensione per IQueryable
interfaccia, mentre le API asincrone restituiscono un'istanza dell'attività per questi metodi.
Note:
Questa funzionalità è disponibile anche in NCache Professional.
Per utilizzare le seguenti API, includi il seguente spazio dei nomi nell'applicazione:
Alachisoft.NCache.EntityFrameworkCore
NCacheIl provider di memorizzazione nella cache di Entity Framework Core contiene le seguenti API per la memorizzazione nella cache delle query:
API sincrone | API asincrone |
---|---|
FromCache |
FromCacheAsync |
LoadIntoCache |
LoadIntoCacheAsync |
FromCacheOnly |
FromCacheOnlyAsync |
FromCache
Il metodo di estensione è ideale da utilizzare quando si gestiscono dati transazionali (con frequenti operazioni di lettura e scrittura). Ad esempio, mantenendo i registri dei voli, in cui ogni volo unico richiede la registrazione continua nel database di nuove voci. In alternativa, per i dati di riferimento (dove le letture sono più frequenti delle scritture), utilizzare LoadIntoCache
ed FromCacheOnly
metodi di estensione. Proprio come in un catalogo di prodotti, in cui i prodotti vengono trattati come dati di riferimento, poiché vengono modificati raramente e letti in modo coerente dal database. Per utilizzare questi metodi di estensione dei dati di riferimento, è necessario definire gli indici di query all'interno dell'applicazione. Questo può essere fatto dinamicamente aggiungendo il file [QueryIndexable]
etichetta.
Memorizzazione dei dati della cache con EFCore
In FromCache
, LoadIntoCache
, FromCacheOnly
e le relative controparti asincrone, è possibile usare le query di memorizzazione nella cache di EF Core per archiviare i dati nella cache per le query successive.
È possibile archiviare i dati nella cache in due modi: archiviare l'intero set di dati come raccolta rispetto a una singola chiave nell'archivio dati utilizzando la chiamata di inserimento. In alternativa, puoi aggiungere ciascuna entità separatamente a più chiavi in blocco. Puoi effettuare questa scelta utilizzando CachingOption StoreAs
impostato StoreAs.Collection
or StoreAs.SeperateEntities
. È possibile specificare e abilitare bulkInsertChunkSize
quando si ha a che fare con un numero considerevole di entità, ad esempio 100,000. Ciò garantisce che i dati vengano caricati nella cache pezzo per pezzo, indipendentemente dalle dimensioni del set di dati, rendendo il processo di archiviazione dei dati più efficiente e gestibile.
Note:
Il bulkInsertChunkSize
La proprietà divide la maggior parte delle entità in blocchi più piccoli e aggiorna la cache pezzo per pezzo. In quanto tale, consente all'operazione di aggirare il timeout della connessione memorizzando nella cache un blocco di entità entro il limite di 90 secondi, impedendo l'attivazione del token di annullamento. Per impostazione predefinita, il bulkInsertChunkSize
è 1000.
Consigli
Poiché l'applicazione riceve una risposta solo dopo che l'intero blocco è stato memorizzato nella cache, è preferibile utilizzare un metodo di estensione Async per evitare ritardi significativi quando si ha a che fare con un set di dati di grandi dimensioni.
DaCache
Il FromCache
Il metodo memorizza nella cache i dati del set di risultati generati rispetto alla query LINQ e li restituisce all'applicazione. Se i dati non esistono nella cache, verranno recuperati dall'origine dati e archiviati nella cache. Se l'applicazione effettua nuovamente la stessa query, otterrà i dati necessari dalla cache, evitando un viaggio non necessario all'origine dati.
Tuttavia, poiché questo metodo avviene su due livelli (ottenimento dei dati del set di risultati e aggiornamento della cache), esiste una maggiore possibilità di fallimento, soprattutto in quest'ultimo caso. Potresti non riuscire ad aggiornare la cache per una serie di motivi. Ad esempio, errore di connessione al database, errore di rete, cache/server inattivo, errore di serializzazione dei dati, scenario di trasferimento di stato, ecc.
Perciò, NCache fornisce agli utenti che impiegano FromCache
con la errorEnabled
flag che consente loro di determinare se desiderano arrestare l'applicazione per eventuali problemi non correlati al set di risultati. In genere, se la memorizzazione nella cache e le prestazioni del sistema sono una priorità, gli utenti imposteranno questo flag su True (poiché la query si occupa ogni volta dell'origine dati, altrimenti). Tuttavia, se la loro priorità è impedire l'arresto dell'applicazione, gli utenti imposteranno questo flag su False.
Note:
Per impostazione predefinita, il errorEnabled
flag è impostato su False.
Note:
Anche se l' errorEnabled
flag è False, queste eccezioni relative all'aggiornamento della cache verranno registrate nei log della cache disponibili all'indirizzo %NCHome%/log-files
.
Esempi
- L'esempio seguente recupera i dettagli del cliente in base a un ID cliente specificato dal database e li archivia come entità separata nella cache con le opzioni di memorizzazione nella cache specificate.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var resultSet = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCache(options).ToList();
}
Note:
Puoi anche monitorare l'attività della tua cache utilizzando il file NCache Tenere sotto controllo.
- L'esempio seguente restituisce la chiave di cache generata internamente rispetto ai dati del set di risultati della query archiviati come raccolta nella cache. Questa chiave può essere salvata per un utilizzo futuro come la rimozione del set di entità/risultati dalla cache.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.Collection
};
var resultSet = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCache(out string cacheKey, options);
}
Note:
Utilizzando Esporta-CacheKeys nello strumento di tua scelta, puoi visualizzare le chiavi di cache di una particolare cache.
Considerazioni su FromCache
FromCache
supporta le seguenti funzioni:
Group By
Order By Ascending
Order By Descending
Sum
Min
Max
Average
Count
Contains
Like
FirstOrDefault
Le funzioni possono essere implementate durante l'utilizzo di LINQ con FromCache
, Come segue:
- Il
Like
L'operatore in EF Core esegue la corrispondenza dei modelli all'interno delle stringhe di caratteri. Di solito viene impiegato conWhere
inSELECT
istruzioni per filtrare le righe in base a modelli o sottostringhe specifici all'interno del valore di una colonna. Inoltre, consente l'uso di caratteri jolly per abbinare uno o più caratteri in una stringa:
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(c => EF.Functions.Like(c.CompanyName, "Alfreds Futterkiste"))
.FromCache(options)
.ToList();
}
- Il
Contains
l'operatore può essere utilizzato in modo simile aLike
operatore di utilizzare ricerche basate su modelli all'interno di un dato criterio.
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(b => (b.CompanyName.Contains("Alfreds Futterkist")))
.FromCache(out cacheKey, options)
}
- Il
FirstOrDefault
L'operatore può essere implementato come dimostrato di seguito.
using (var context = new NorthwindContext())
{
var result = context.Products
.Where(b => b.UnitPrice > 1)
.FromCache(out cacheKey, options)
.FirstOrDefault();
}
- Il
GroupBy
può essere utilizzato con la proiezione per FromCache come implementato di seguito.
using (var context = new NorthwindContext())
{
var resultSet = context.Products
.Where(p => p.UnitPrice == 10)
.GroupBy(p => p.ProductName)
.Select(group => group.Key)
.FromCache(out cacheKey, options)
.ToList();
}
Carica nella cache
Il LoadIntoCache
L'API recupera i dati del set di risultati dall'origine e li memorizza nella cache senza restituirli all'applicazione. Questa API consente i successivi FromCache
chiamate per produrre dati aggiornati. IL LoadIntoCache
Il metodo è particolarmente adatto per dati aggiornati frequentemente come ordini dei clienti o dati sensibili come i dettagli di pagamento. In tali scenari, l'utilizzo di dati obsoleti può comportare transazioni commerciali errate, pertanto, nella cache deve essere sempre presente una nuova copia dei dati. Questo metodo di estensione carica il set di dati funzionante completo nella cache. Quindi, questo metodo interroga il database, memorizza il risultato nella cache e lo restituisce all'applicazione.
Esempi
- L'esempio seguente recupera gli ordini dei clienti dal database e carica i dati del set di risultati nella cache come raccolta. Restituisce inoltre la chiave di cache generata internamente che può essere salvata per uso futuro.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.Collection
};
var resultSet = (from custOrder in context.Orders
where custOrder.Customer.CustomerId == someCustomerId
select custOrder).LoadIntoCache(out string cacheKey, options);
}
- L'esempio seguente carica i dettagli specifici dell'ordine dal database nella cache come entità separate con le opzioni di memorizzazione nella cache specificate.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var resultSet = (from custOrder in context.Orders
where custOrder.Customer.CustomerId == someCustomerId
select custOrder).LoadIntoCache(options);
}
- Il
GroupBy
può essere utilizzato con la proiezione perLoadIntoCache
come implementato di seguito.
using (var context = new NorthwindContext())
{
var resultSet = context.Products
.Where(p => p.UnitPrice == 10)
.GroupBy(p => p.ProductName)
.Select(group => group.Key)
.LoadIntoCache(out cacheKey, options)
.ToList();
}
Puoi eseguire questo metodo a intervalli regolari ogni volta che prevedi che i dati cambino. Ad esempio, se prevedi modifiche ai dati entro una settimana, eseguirlo nuovamente dopo tale periodo garantisce che i dati nella cache vengano aggiornati.
FromCacheOnly
Per i dati che vengono aggiornati meno frequentemente, come i dettagli dei clienti, recuperarli regolarmente dall'origine dati è costoso. FromCacheOnly
interroga le entità presenti nella cache e non si avvicina in nessun caso alla sorgente dati. In sostanza, se l'entità non esiste nella cache, non verrà comunque recuperata dall'origine dati.
Note:
Questa API funziona solo quando le entità vengono archiviate separatamente, ovvero con l'opzione di memorizzazione nella cache StoreAs
è impostato su SeperateEntities
.
Consigli
Le entità devono essere indicizzate nel file NCache Management Center prima dell'utilizzo FromCacheOnly
.
- L'esempio seguente recupera le informazioni sul cliente dalla cache se il file entità esiste. In caso contrario, il set di risultati restituito sarà vuoto.
using (var context = new NorthwindContext())
{
var resultSet = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCacheOnly();
}
Considerazioni su FromCacheOnly
FromCacheOnly
supporta funzioni aggregate. Tuttavia, queste funzioni memorizzano nella cache solo il risultato e non le entità stesse. Quindi, NCache fornisce il QueryDeferred
metodo che rinvia la query in modo che le entità nella cache ottengano il risultato in risposta a una query. Per maggiori dettagli sulle API differite fare riferimento al capitolo Interroga API differite. FromCacheOnly
supporta le seguenti funzioni:
Group By
Order By Ascending
Order By Descending
Sum
Min
Max
Average
Count
Contains
Like
Tieni presente le seguenti considerazioni durante l'utilizzo di LINQ con FromCacheOnly
:
Eccetto per
Count
, tutte le funzioni aggregate devono avere valori interi.Count
deve essere dotato di un'entità da contare.Una singola espressione LINQ per
FromCacheOnly
non è possibile utilizzare più di una funzione aggregata.Le proiezioni nelle espressioni LINQ possono essere eseguite solo se a
GroupBy
vengono utilizzati l'operatore e una funzione aggregataFromCacheOnly
.Non sono supportate proiezioni multiple. In un'espressione LINQ è possibile proiettare un solo attributo (che viene portato avanti).
using (var context = new NorthwindContext())
{
var result = context.Employees
.Select(e => e.EmployeeId) // Multiple projections have not been performed
.GroupBy(eid => eid) // eId was projected so GroupBy had to be used
.DeferredMin() // MIN provided with a numeric attribute
.FromCacheOnly();
}
GroupBy
viene utilizzato principalmente per funzioni di aggregazione (raggruppamento del risultato di query mediante colonne) e può essere utilizzato solo se la proiezione è stata completata in anticipo e viene utilizzata una funzione di aggregazione.GroupBy
deve essere l'ultimo operatore nell'espressione LINQ tranne ifOrderBy
si usa. In tali casi, ilGroupBy
la funzione può essere spostata in avanti (dopoOrderBy
) o indietro (primaOrderBy
).
using (var context = new NorthwindContext())
{
var result = context.Products
.Where(data => data.ProductName == "Tofu")
.GroupBy(data => new { data.ProductName})
.Select(group => new
{
_String = group.Key.ProductName,
Count = group.Count()
})
.FromCacheOnly();
}
OrderBy
(sia ascendente che discendente) può essere utilizzato solo in un'espressione LINQ forFromCacheOnly
, SeGroupBy
viene utilizzato.Più di una
GroupBy
edOrderBy
gli operatori non possono essere utilizzati in una singola espressione LINQ forFromCacheOnly
.I join non sono supportati, quindi il
Include()
il metodo non funzionerà.Per le espressioni LINQ contenenti il
DateTime
istanze, tutti i nodi in un cluster di cache devono avere lo stessoDateTime
formato impostato. In caso contrario, si verificherà un'eccezione di formato. Questo problema sorge quando ilDateTime.Now
edDateTime.Parse()
vengono utilizzati in un cluster di cache multi-nodo. Per evitarlo, sincronizzare il fileDateTime
formato su entrambe le macchine. Inoltre, usaDateTime.ParseExact()
ancoraDateTime.Parse()
, Come l'ParseExact()
L'API impedisce all'utente di specificare un formato perDateTime
.Il
Like
L'operatore in EF Core esegue la corrispondenza dei modelli all'interno delle stringhe di caratteri. Di solito viene impiegato conWhere
inSELECT
istruzioni per filtrare le righe in base a modelli o sottostringhe specifici all'interno del valore di una colonna. Inoltre, consente l'uso di caratteri jolly per abbinare uno o più caratteri in una stringa:
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(c => EF.Functions.Like(c.CompanyName, "Alfreds Futterkiste"))
.FromCacheOnly()
.ToList();
}
- Il
Contains
l'operatore può essere utilizzato in modo simile aLike
operatore di utilizzare ricerche basate su modelli all'interno di un dato criterio.
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(b => (b.CompanyName.Contains("Alfreds Futterkist")))
.FromCacheOnly()
}
- Il
Contains
L'operatore può essere utilizzato anche per effettuare ricerche in un dizionario.
using (var context = new NorthwindContext())
{
var customerList = new List<string> { "CustomerId", "Alfreds Futterkiste" };
var result = context.Customers
.Where(b => customerList.Contains(b.CompanyName))
.FromCacheOnly();
}
API LINQ asincrone
Le API asincrone hanno le stesse funzionalità delle loro controparti sincrone, ma con un comportamento asincrono. Anche i parametri passati a questi metodi sono gli stessi.
Consigli
A causa della sua natura asincrona, cacheKey
non viene restituito in nessuna delle chiamate asincrone come FromCacheAsync
ed LoadIntoCacheAsync
- come out
i parametri non sono consentiti con metodi con firma asincrona.
FromCacheAsync
I dati vengono recuperati direttamente dal database se la connessione alla cache non riesce. Tuttavia, dopo ogni 60 secondi dall'esecuzione della richiesta, viene ritentata la connessione alla cache. Le richieste successive proveranno a reinizializzare la cache dopo 60 secondi dall'ultima richiesta. Ogni volta che una connessione viene stabilita con successo, i dati vengono recuperati dalla cache.
L'esempio seguente recupera i dettagli del cliente in base a un oggetto specificato identificativo del cliente dal database in modo asincrono e li archivia come entità separata nella cache con le opzioni di memorizzazione nella cache specificate.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var task = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCacheAsync(options);
task.Wait();
var resultSet = task.Result.ToList();
}
CaricaIntoCacheAsync
L'esempio seguente carica i dettagli specifici dell'ordine dal database nella cache come entità separate con le opzioni di memorizzazione nella cache specificate.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var task = (from custOrder in context.Orders
where custOrder.Customer.CustomerId == someCustomerId
select custOrder).LoadIntoCacheAsync(options);
task.Wait();
var resultSet = task.Result.ToList();
}
FromCacheOnlyAsync
L'esempio seguente recupera le informazioni sul cliente solo dalla cache se il file l'entità esiste. In caso contrario, il set di risultati restituito sarà vuoto, poiché il database viene ignorato.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var task = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCacheOnlyAsync();
task.Wait();
var resultSet = task.Result.ToList();
}
Vedere anche
.NETTO: Alachisoft.NCache.EntityFrameworkCore spazio dei nomi.
.NETTO: Alachisoft.NCache.Memorizzazione.della.cache spazio dei nomi.