utilizzando NCache in EF Core e SQL Server

Oggi vi mostrerò come potete integrare NCache nelle applicazioni Entity Framework Core esistenti per trarne i vantaggi elevate prestazioni e scalabilità. C'è molto di cui parlare, quindi mi limiterò a passare direttamente all'argomento.

Esempio di applicazione EF Core

La prima cosa che abbiamo è questa esempio di applicazione Entity Framework Core che ho che utilizza i database SQL Northwind. Quindi, se veniamo qui, puoi vedere che sto recuperando questi ordini tra gli ID ordine 10249 e 10268 e possiamo vedere che sto recuperando questi clienti dagli Stati Uniti e questi prodotti tra gli ID prodotto 10 e 20. Questo è tutto ciò che sta facendo questo campione. Andiamo avanti e diamo un'occhiata ai risultati che questo ci recupererà dal database. Perfetto. Quindi, possiamo vedere che recuperiamo questi prodotti tra 10 e 20, questi 11 prodotti, questi 13 clienti dagli Stati Uniti e questi 20 ordini tra questi ID ordine.

Quindi, ora che l'esempio è stato eseguito, diamo un'occhiata al database con cui stiamo lavorando. Quindi, come puoi vedere, stiamo lavorando con i database Northwind e questi sono i clienti che esistono già nella tabella dei nostri clienti. Quindi va tutto bene, abbiamo visto il lavoro di esempio.

Passaggi di integrazione

Ora parliamo di come possiamo integrarci NCache in questa applicazione Entity Framework Core esistente. Lo faremo utilizzando cinque passaggi molto semplici.

Installazione NCache Pacchetto Nuget EF Core
Aggiungi NCache Spazio dei nomi EntityFrameworkCore
Specificare le configurazioni della cache in DbContext
Rendi serializzabili i modelli
Usa il NCache Metodi di estensione di EF Core

Installazione NCache Pacchetto Nuget EF Core

Quindi, il primo passo sarà installare il file NCache Pacchetto NuGet Entity Framework Core nell'applicazione. Quindi, se gestisco i pacchetti NuGet per questa applicazione, possiamo vedere che ho già installato EntityFrameworkCore.NCache Pacchetto NuGet che corrisponde a NCache 5.3SP2. Perfetto. Quindi, lo chiuderò e basta.

Aggiungi NCache Spazio dei nomi EntityFrameworkCore

Diamo un'occhiata al passaggio successivo. Quindi, il passo successivo è aggiungere il file NCache Spazio dei nomi Entity Framework Core nella nostra applicazione. Quindi, se vengo qui devo solo aggiungere "using Alachisoft.NCache.EntityFrameworkCore". Dovrò fare lo stesso per il mio contesto. Quindi, lo salvo qui, mi sposto nel contesto e lo incollerò anche lì e lo salverò, perfetto.

Specificare le configurazioni della cache nel contesto del database

Ora, il passo successivo è specificare le configurazioni della cache nel contesto del database. Ora, se scorro verso il basso, cerco il mio metodo "OnConfiguring". Quindi eccolo qui, il metodo OnConfiguring. E qui quello che farò è aggiungere la cache con cui sto lavorando, quindi qui c'è "efcorecache" e aggiungo "NCacheConfiguration.Configure' e dico che questa cache e il tipo di dipendenza sono SQL server poiché sto lavorando con un server SQL, perfetto.

Dipendenza della cache su SQL Server

Rendi serializzabili i modelli

E ora che ciò è stato fatto, il passo successivo è rendere i nostri modelli serializzabili. Quindi, andrò ai miei modelli, andrò dal mio cliente e aggiungerò semplicemente [Serializable], perfetto. Lo copierò, andrò all'ordine e lo incollerò lì, lo salverò e nel prodotto, e lo incollerò lì, perfetto. Quindi, ora che ho finito, guarderò questo dipendente e ti mostrerò che ho già contrassegnato tutti gli altri modelli come serializzabili, quindi non ho bisogno di farlo per altri modelli.

Usa il NCache Metodi di estensione di EF Core

Quindi, ora che i nostri modelli sono contrassegnati come serializzabili, arriviamo al quinto passaggio. E il quinto passaggio è il più interessante in cui utilizzeremo il file reale NCache Metodi di estensione core di Entity Framework all'interno della nostra applicazione. Ora, questo dipenderà dal caso d'uso dei dati esistenti nella nostra applicazione e questi potrebbero essere uno dei due casi d'uso. Potremmo avere dati transazionali o dati di riferimento nella nostra applicazione.

Gestione dei dati transazionali

Pertanto, se parliamo di dati transazionali e quando parliamo di gestione dei dati transazionali, i dati transazionali sono i dati che dovrebbero essere letti e scritti con estrema frequenza. Un buon esempio di questi dati sarebbe tenere un registro dei voli. Quindi, ci sono molti voli che avvengono in un giorno e tutti hanno qualcosa di diverso, quindi se li registrassi in un database scriveresti costantemente nuovi voli e questo può essere considerato un caso d'uso transazionale . Pertanto, quando abbiamo questo tipo di caso d'uso transazionale nelle nostre applicazioni, per questo tipo di dati diciamo che è ideale utilizzare il metodo di estensione "FromCache".

Ora, ciò che fa il metodo di estensione FromCache è la prima volta che funziona, funziona e si comporta come una normale applicazione Entity Framework Core in cui le tue entità vengono recuperate dal database. Tuttavia, in questo momento il metodo FromCache popola quelle entità nella cache e il vantaggio di ciò è che la prossima volta che dovrai chiamare quelle query o avrai bisogno di quelle entità nella tua applicazione non tornerai indietro al database per ottenere quelle entità e invece recuperi rapidamente quelle entità dalla cache e ricevi il vantaggio di prestazioni elevate e ottieni rapidamente tutti i tuoi dati pronti per essere inseriti nella tua applicazione.

Ora andiamo avanti e realizziamo effettivamente questa implementazione e diamo un'occhiata a come funziona. Quindi, tornando alla nostra applicazione, quello che farò qui è che lavorerò con gli ordini e aggiungerò alcune opzioni di memorizzazione nella cache degli ordini, eccoci qua, e dico che ho "nuove CachingOptions() ' qui e definirò semplicemente "StoreAsType" come una "Collezione". Quindi, voglio che tutti gli ordini vengano archiviati come un'unica raccolta nella cache. Voglio anche che questi scadano, quindi aggiungerò una scadenza quindi andrò su "SetSlidingExpiration" aggiungerò un "TimeSpan()" di 10 minuti in modo che questi ordini scadano dopo 10 minuti, perfetto . E ora che ho finito, scorrerò qui in basso e aggiungerò il metodo di estensione ".FromCache" e aggiungerò "order_caching_options", perfetto. Questo è tutto quello che devo fare qui.

var order_caching_options = new CachingOptions()
{
	StoreAs = StoreAs.SeparateEntities
};
order_caching_options.SetSlidingExpiration(new TimeSpan(0, 10, 0));

//Orders 
var order_resultset = context.Orders
		     .Where(o => o.OrderId >= 10249 && o.OrderId <= 10268)
		     .FromCache(order_caching_options)
		     .ToList();

Console.WriteLine($"Orders between 10249 and 10268 fetched: {order_resultset.Count}
\n--------------------------------------------------------------------------\n\n"
+ String.Format("{0,-25}  {1,-40}  {2,-10}", $"Order ID", $"Date", $"Shipper Name") + "\n");

order_resultset.ForEach(order =>
{
    Console.WriteLine(String.Format("{0,-25}  {1,-40}  {2,-10}", $"{order.OrderId}", $"{order.OrderDate}", $"{order.ShipName}"));
});

Ora, prima di eseguirlo, diamo un'occhiata alla nostra cache. Ora, qui ho la configurazione "EFCoreCache" sui miei due nodi che possiamo vedere qui. Se vai al Monitor possiamo vedere che è completamente connesso, sano, funzionante e in buona forma, senza nulla all'interno. E, se andiamo alle statistiche, questo ci dice la stessa storia, è una cache sana con zero oggetti all'interno pronti all'uso, perfetti. Ora andiamo avanti ed eseguiamo la nostra applicazione e diamo un'occhiata ai risultati che otteniamo, perfetti.

Ora che l'applicazione è eseguita, chiuderò questa finestra della console qui e possiamo vedere queste richieste che abbiamo ricevuto nella nostra cache in questa aggiunta avvenuta, e se scorriamo verso il basso possiamo vedere questo conteggio, il che significa che la nostra raccolta è stata popolata nella cache.

Ora, se eseguo "export-cachekeys", perfetto, possiamo vedere questa raccolta che è stata inserita nella cache. Ora, supponiamo di voler aggiungere ogni ordine come entità separata, quindi quello che farò è aggiungere "SeparateEntities" al tipo "StoreAs" anziché alla raccolta. Eseguire nuovamente questa applicazione . E ora ciò che farà è che invece di quella singola raccolta aggiungerà quegli ordini come entità separate. Ora che le applicazioni vengono eseguite, posso chiuderle e possiamo vedere tutta l'attività avvenuta e, soprattutto, queste aggiunte. Queste 16 e 4 aggiunte e questo conteggio è aumentato.

Quindi, se andiamo su Statistiche possiamo vedere 16 e 5. Ora esporteremo di nuovo le chiavi della cache e possiamo vedere che abbiamo un conteggio di 21 cache e tutti i nostri ordini sono stati popolati come separati entità nella cache e in una raccolta. Quindi è perfetto e in un certo senso riassume il modo in cui viene utilizzato il metodo di estensione FromCache.

Gestione dei dati di riferimento

Ora parliamo di come gestisci i dati di riferimento e di cosa sono i dati di riferimento. I dati di riferimento sono il tipo di dati che vengono letti molto più frequentemente di quanto non vengano mai scritti. Quindi, questi sono dati che più o meno rimangono piuttosto statici. Ad esempio, hai un catalogo di prodotti. Ora non è previsto che i tuoi prodotti cambino molto frequentemente, quindi potrebbero essere dati di riferimento che vengono costantemente letti dal database e raramente, se non mai, modificati. E, nel caso dei dati di riferimento, la raccomandazione è di portare l'intero set di dati di riferimento nella cache e quindi leggere dalla cache solo ogni volta che si desidera recuperare tali dati di riferimento. Lascia che ti mostri come lo farai.

Quindi, il primo metodo che abbiamo, o il secondo metodo di estensione che abbiamo, è il metodo di estensione "LoadIntoCache()". Ora, il metodo di estensione LoadIntoCache() è estremamente potente per caricare il set di dati di lavoro completo nella cache. Quindi, questo andrà ed eseguirà la query sul database, otterrà il risultato della query e popolerà l'intero risultato della query nella cache, quindi restituirà quel risultato all'applicazione.

E questo è ancora utile per portare i dati nella cache e puoi eseguirlo a intervalli regolari ogni volta che prevedi che i dati cambino. Pertanto, se prevedi che i dati cambino entro una settimana, puoi eseguirli di nuovo dopo una settimana per continuare ad aggiornare i dati nella cache e per assicurarti di non ricevere risultati parziali quando esegui query solo dalla cache per queste entità. Parlando di query solo dalla cache, il modo in cui lo faresti è utilizzare il metodo di estensione "FromCacheOnly()". Ora, il metodo di estensione FromCacheOnly() cerca sempre e solo i dati all'interno della cache e non va mai al database back-end per ottenere tali risultati. Questo è un metodo di estensione estremamente veloce e garantisce di ricevere tutti i vantaggi in termini di prestazioni della memorizzazione nella cache in memoria poiché ricevi tutte le entità da una cache in cluster e non stai mai esaminando il tuo database.

Ora andiamo avanti e implementiamo questi metodi di estensione nella nostra applicazione. Ma c'è un prerequisito che dobbiamo completare prima di usarli. Pertanto, per utilizzare questi metodi di estensione dei dati di riferimento dovremmo definire gli indici delle query all'interno della nostra applicazione e ciò può essere fatto in due modi. Ora posso creare dinamicamente questi indici di query qui aggiungendo il tag "[QueryIndexable]" che porterà anche lo spazio dei nomi "NCache.Runtime.Caching" nell'applicazione e ora l'ho fatto dinamicamente. Ma lo farò in un altro modo. Quindi, lo commenterò qui e, se vado alle cache del mio cluster, posso mostrarti che ho già definito questi indici di query nella mia cache, come possiamo vedere qui.

Quindi, poiché l'ho già fatto, non ho bisogno di aggiungerli dinamicamente all'interno della mia applicazione. Quindi, ora che è stato stabilito, scorrerò qui in basso e ho questo pezzo di codice qui, e tutto ciò che fa, semplicemente rimuoverlo dal commento, è recuperare i prodotti dal database. Li memorizzerà come entità separate utilizzando il metodo di estensione "LoadIntoCache()", e questo è tutto ciò che farà. Quindi ora andrò avanti ed eseguirò questo, e diamo un'occhiata ai risultati che ottiene, perfetto.

//Load ALL Products Into Cache
var products_caching_option = new CachingOptions
{
    StoreAs = StoreAs.SeparateEntities
};
var all_products = (from products in context.Products
                    select products)
                    .LoadIntoCache(products_caching_option)
                    .ToList();
Console.WriteLine($"\n\nAll Products Loaded into cache : {all_products.Count}\n\n");
all_products.ForEach(product =>
{
    Console.WriteLine(String.Format("{0,-25}  {1,-40}  {2,-10}", $"{product.ProductId}", $"{product.ProductName}", $"{product.UnitPrice}"));
});

Quindi, possiamo vedere che questi 77 prodotti sono stati caricati nella cache, e possiamo vedere questo conteggio che è aumentato vertiginosamente, queste aggiunte che si sono verificate e queste richieste che sono arrivate. Se andiamo alle statistiche possiamo vedere 42 e 57.

Ora esporterò di nuovo le chiavi della cache, perfetto. Quindi, possiamo vedere questi 99 elementi nella nostra cache e il nostro intero set di prodotti funzionante è stato portato nella cache. Ora che abbiamo l'intero set di lavoro nella cache, è sicuro per me tornare al punto in cui stavo interrogando i prodotti, quindi commenterò semplicemente questo, andremo su e " Aggiungerò il metodo di estensione "FromCacheOnly()" in cui stavo recuperando i miei prodotti, perfetto. E ora che è fatto, posso semplicemente eseguire nuovamente l'applicazione. E diamo un'occhiata ai risultati che la mia applicazione recupera rispetto al metodo di estensione "FromCacheOnly()". Eccoci qua.

Quindi, possiamo vedere che abbiamo ottenuto lo stesso numero di prodotti, quegli 11 prodotti, quindi sappiamo di avere un risultato completo qui e possiamo vedere che questo recupero è avvenuto dalla nostra cache e questa attività che significa che questo FromCacheOnly( ) ha funzionato e ha recuperato i risultati dalla cache.

EF Core specifico NCache API

Quindi, questo è tutto per i metodi di estensione FromCacheOnly() e LoadIntoCache(). Ora possiamo parlare di EF Core specifico NCache API. Così, NCache ti dà la possibilità di non dover necessariamente utilizzare un metodo di estensione per inserire o rimuovere dati dalla cache. È anche possibile recuperare l'handle della cache dal contesto utilizzando la libreria EF Core e quindi utilizzando l'handle della cache è possibile inserire entità indipendenti e rimuovere entità indipendenti dalla cache. Una cosa che vorrei aggiungere qui è che questo non è lo stesso di NCache API disponibili all'interno di NCache SDK e questa è l'API dedicata o specifica di Entity Framework Core.

Quindi, se diamo un'occhiata a queste API e diamo un'occhiata a come funzionano. Quindi, ecco come li useremmo. Quindi, recupereremo la cache dal contesto e quindi inseriremo i dati nella cache semplicemente eseguendo un cache.Insert rispetto al cliente e fornendo una chiave di cache della stringa di uscita. Questa chiave di cache verrà generata dalle API Entity Framework Core. E, quindi, quando desideri rimuovere un dato o rimuovere alcuni elementi dalla cache utilizzando lo stesso handle di cache, potresti, ad esempio, trovare i dati all'interno della cache utilizzando un context.find e quindi eseguire semplicemente un cache.Remove.

Ora andiamo avanti ed eseguiamo queste operazioni nella nostra applicazione. Quindi, se torno alla mia applicazione qui e scorro qui, ho questo frammento di codice qui che aggiunge il cliente alla cache. Toglierò il commento a questo codice e se scorri verso l'alto possiamo vedere che sto semplicemente ottenendo la cache dal contesto creando questo cliente e voglio memorizzarlo come un'entità separata, voglio salvare le modifiche ed esegui questa cache. Inserisci, quindi scrivi che ho aggiunto questo cliente alla cache. Quindi, andiamo avanti, eseguiamolo e diamo un'occhiata a cosa fa.

//Add Customer Using Cache Handle
Cache cache = context.GetCache();
var cust = new Customer
{
    CustomerId = "HANIH",
    ContactName = "Hanih Moos",
    ContactTitle = "Sales Representative",
    CompanyName = "Blauer See Delikatessen",
};

var options = new CachingOptions
{
    StoreAs = StoreAs.SeparateEntities
};

context.Customers.Add(cust);
context.SaveChanges(true);

cache.Insert(cust, out string cacheKey, options);
Console.WriteLine($"Customer ID: {cust.CustomerId} -> Added to Cache");

Quindi, possiamo vedere che abbiamo aggiunto questo cliente alla cache. Quindi, se chiudo questa applicazione, possiamo vedere questa aggiunta che è stata eseguita su queste richieste, e possiamo vedere un piccolo calo, quindi siamo passati da 42 a 43. Se andiamo alle statistiche possiamo vedere 43 e 57 che completa 100. Quindi, se esporto le chiavi della cache possiamo vedere quel cliente indipendente, ecco fatto. Quindi, possiamo vedere quell'entità separata e indipendente che abbiamo aggiunto alla cache. È perfetto.

Ora andiamo avanti e rimuoviamo questo cliente. Quindi, commenterò semplicemente questo pezzo di codice. Ancora una volta, scorrerò qui in basso e rimuoverò il commento da questo pezzo di codice, e tutto ciò che fa questo pezzo di codice è cercare il cliente nella cache con lo stesso nome cliente e, se trova quel cliente, è rimuoverlo dal contesto, salvare le modifiche, quindi rimuoverlo dalla cache. E poi stamperà che lo ha fatto. Altrimenti dirà che non è riuscito a trovare il cliente.

//Remove Customer Using Cache Handle
Cache cache = context.GetCache();
Customer customerToRemove = context.Customers.Find("HANIH");
if (customerToRemove != null)
{
    context.Customers.Remove(customerToRemove);
    context.SaveChanges(true);
    cache.Remove(customerToRemove);
    Console.WriteLine($"Customer ID: {customerToRemove.CustomerId} -> Removed from Cache");
}
else
{
    Console.WriteLine("could not find the customer within the cache");
}
Console.ReadLine();

Quindi, andiamo avanti ed eseguiamo questa applicazione e diamo un'occhiata ai risultati, perfetto. Quindi, possiamo vedere che il cliente è stato rimosso dalla cache, e possiamo vedere nelle statistiche che siamo passati da 43 a 42, e il monitor mostrerebbe la stessa cosa, perfetto.

Quindi, ora, se torniamo alle statistiche, aprirò semplicemente il NCache PowerShell e esporterò le chiavi della cache, perfetto. E possiamo vedere che non abbiamo più quel cliente nella nostra cache. Ed è così che puoi aggiungere e rimuovere clienti o qualsiasi dato utilizzando il file NCache API specifiche di EF Core.

Passi successivi

Scaricare NCache

E questo ci porta alla fine di questa dimostrazione, grazie mille. Se lo desidera scaricare NCache puoi ricevere una prova gratuita di 30 giorni e un prodotto completo e funzionante dalla nostra pagina di download. Lascia che ti ci porti adesso. Quindi se veniamo qui puoi vedere qui che queste sono le offerte per .NET che puoi scaricare per Windows e per Linux che NCache fornisce.

Prova Parco giochi

Inoltre, puoi provare NCache fuori nel NCache Terreno di gioco. E puoi effettivamente avere un'idea del prodotto per vedere come funzionano le funzionalità. Quindi, se vai qui al Prova Parco giochi puoi vedere che puoi avviare questa sessione sandbox per 30 minuti che ti consente di eseguire alcuni esempi e di vedere come verrebbero eseguiti e come si sentirebbero gli esempi .NET e Java.

Pianifica un appuntamento personalizzato NCache Dimo

E infine, puoi prenotare un servizio personalizzato NCache demo in cui ti forniremo una sessione tecnica di un'ora in cui discuteremo NCache architettura e funzionalità, e mapparle in base al caso d'uso che troviamo all'interno dei tuoi ambienti. E farlo è estremamente semplice. Dovresti semplicemente visitare il nostro sito Web qui e programmare questa demo live personalizzata questa pagina qui. E, una volta che sei qui, puoi inviare la richiesta, la riceveremo e pianificheremo qualcosa. E questo ci porta alla fine di questa demo. Grazie mille per la visione, buona giornata. Arrivederci.