utilizzando NCache in EF Core con Oracle

Ciao a tutti, sono Sean e oggi vi mostrerò come potete integrarvi NCache nel tuo esistente Applicazioni Entity Framework Core configurati con un database Oracle. Lo faremo come dimostrazione pratica in cui lavoreremo con un'applicazione di esempio che ho già configurato per questa demo e integreremo NCache dentro. Quindi abbiamo messo in fila cose piuttosto interessanti. Lascia che ti mostri come lo faremo.

Esempio di applicazione EF Core

Quindi, la prima cosa che ho qui è l'applicazione di esempio stessa. Quindi, puoi vedere qui, ho l'applicazione di esempio e sto recuperando alcuni ordini, clienti e prodotti qui. E l'ho configurato per funzionare con un database Oracle, che posso mostrarti qui. Se andiamo al contesto, puoi vedere che ho questo metodo UseOracle qui per lavorare con il mio database Oracle.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
   optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}

Quindi, prima di eseguire effettivamente questo programma, lasciate che vi porti al database e vi mostri con cosa stiamo lavorando. Quindi, sto lavorando con il database Northwind in Oracle. E poiché abbiamo molti tavoli, ho aperto quelli con cui sto lavorando qui in modo che possiamo vederli. Il primo è ORDERS e qui possiamo vedere queste proprietà per gli ordini con cui lavoreremo. Allora diamo un'occhiata ai nostri PRODOTTI. Quindi, queste sono le proprietà del prodotto che otterremo o recupereremo nella nostra applicazione. E poi, la terza tabella è CLIENTI e possiamo vedere le proprietà dei nostri clienti proprio qui. E questi sono praticamente tutti i tavoli con cui lavoreremo.

Quindi ora interroghiamo effettivamente queste tabelle e diamo un'occhiata a cosa abbiamo all'interno. Quindi, puoi vedere che ho 77 prodotti nel mio database Northwind e questi sono tutti i prodotti proprio qui. Quindi va tutto bene. Ora diamo un'occhiata a CLIENTI, clienti, ed inseriamo, e se scorro fino in fondo - perfetto! Quindi, possiamo vedere che ho 89 clienti nel mio database Northwind e tutti quei clienti sono proprio qui, come puoi vedere di fronte a te.

Ora diamo un'occhiata ai nostri ordini. Ora ci saranno molti ordini, scorriamo fino in fondo: perfetto! Quindi, possiamo vedere che abbiamo 830 ordini nel nostro database. Sono moltissimi ordini e possiamo vederli tutti qui. Quindi, effettueremo il recupero di alcuni criteri nell'applicazione e lo esamineremo ora.

Quindi ora che l'applicazione è stata eseguita, possiamo vedere perfettamente. Ora lasciami scorrere qui per vedere che possiamo recuperare questi prodotti tra ID 25 e 50. Quindi, abbiamo 26 prodotti; clienti che provengono dal Regno Unito, quindi abbiamo sette clienti; e ordini compresi tra 10280 e 10300, quindi abbiamo questi 21 ordini: perfetti!

NCache Configurazione per EF Core

Quindi, ora che sappiamo che l'esempio funziona, possiamo passare alla configurazione NCache nella nostra applicazione Entity Framework Core. Quindi, configurando la nostra applicazione con cui lavorare NCache è semplice quanto cinque passaggi che eseguiremo in questa dimostrazione.

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, iniziamo con il primo passaggio, ovvero installare il file NCache Pacchetto NuGet Entity Framework Core nella nostra applicazione. Pertanto, se vado ai pacchetti NuGet nella mia applicazione, stiamo cercando EntityFrameworkCore.NCache Pacchetto NuGet, che si trova proprio qui. L'ho installato nella mia applicazione, quindi possiamo vederlo qui. E sto eseguendo la versione 5.3.2.1, che corrisponde a NCache versione 5.3 SP2. Quindi è perfetto. Ora andiamo avanti e chiudiamo questa scheda e passiamo al passaggio successivo.

Aggiungi NCache Spazio dei nomi EntityFrameworkCore

Quindi, il passo successivo è aggiungere il file NCache Spazio dei nomi Entity Framework Core nell'applicazione. Quindi, apriamo di nuovo il codice ed entriamo nel nostro programma qui. E aggiungerò semplicemente:

using Alachisoft.NCache.EntityFrameworkCore

Perfetto! Quindi, salverò questo, andrò al contesto del modello e lo incollerò qui: perfetto! Quindi, ora che abbiamo finito, possiamo andare al passo successivo, ovvero specificare le configurazioni della cache nel contesto del database.

Specificare le configurazioni della cache nel contesto del database

Quindi, scorrerò verso il basso fino al mio metodo di configurazione e aggiungerò il nome della cache con cui lavoreremo e passerò il NCache configurazione. Quindi, questo sarà il mio 'efcoreoraclecache': perfetto! E devo aggiungere il NCacheConfigurazione.Configura il nome della cache insieme al DependencyType, che sarà Oracle: perfetto! E questo è praticamente tutto quello che devo fare qui.

...
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
   string cache = "efcoreoraclecache";

   NCacheConfiguration.Configure(cache, DependencyType.Oracle);

   optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}
...

Ora diamo un'occhiata alla cache con cui lavoreremo. Quindi puoi vedere che ho il mio EFCoreOracleCache configurato proprio qui su queste due macchine demo. E diamo un'occhiata ai dettagli di questa cache. Quindi, da qui, se vogliamo monitorare questa cache, possiamo fare clic su questo pulsante di monitoraggio. Questo ci porterà al monitor qui che ci mostra lo stato della nostra cache, e possiamo vedere che è buona, pulita e abbiamo una cache sana con cui lavorare.

Se torniamo ai nostri dettagli e clicchiamo su statistiche, questo ci porterà a questa pagina qui che ci mostra le statistiche della nostra cache. Ora, se torniamo al nostro monitor, torniamo alla nostra applicazione e apriamo il passaggio successivo.

Rendi serializzabili i modelli

Quindi, il prossimo passo è rendere serializzabili i nostri modelli. Perfetto. Quindi ora andrò al mio modello cliente. Quindi sarà laggiù. Perfetto. E aggiungerò semplicemente [Serializzabile] qui. Perfetto. Quindi ora che ho finito, posso passare al mio ordine. E puoi vedere che è già contrassegnato come [Serializzabile]. E il mio prodotto, che ancora una volta è già contrassegnato come [Serializzabile]. Quindi tutti i miei modelli sono serializzabili e siamo a posto. Quindi ora possiamo passare al passaggio successivo.

Usa il NCache Metodi di estensione di EF Core

Il prossimo passo è usare il NCache Metodi di estensione di Entity Framework Core all'interno della nostra applicazione. E farò una pausa qui perché i metodi di estensione che scegliamo di utilizzare dipenderanno dal tipo di dati che stiamo effettivamente memorizzando nella cache.

Quindi ci sono due tipi di dati che possiamo memorizzare nella cache: il primo tipo è transazionale e il secondo è di riferimento. Cosa siano questi tipi e come dovresti gestirli è qualcosa di cui parleremo tra poco. Parliamo quindi del primo. Perfetto.

Gestione dei dati transazionali

Pertanto, il primo tipo di dati che puoi gestire sono i dati transazionali. Ora, i dati transazionali sono dati che hanno un caso d'uso intensivo di lettura e di scrittura. Quindi un buon esempio di ciò sarebbero i dati di volo in cui ogni giorno ci sono così tanti voli e tali dati vengono scritti nel database ogni giorno e vengono anche recuperati dal database ogni giorno. Quindi questo è un caso d'uso molto intensivo di lettura e scrittura che qualifica i dati come transazionali. Nel nostro caso, un caso d'uso simile può essere mappato ai nostri ordini. Quindi possiamo considerare i nostri ordini come i nostri dati transazionali. Quindi, quando parliamo di gestire i dati transazionali in Entity Framework Core con NCache, useremo il Dalla cache() metodo di estensione.

Ora, quando associ questo metodo di estensione alle query esistenti, la prima volta che lo esegui verrà eseguito come una query standard. La tua applicazione andrà al database e recupererà le entità da lì. Tuttavia, questa volta la tua applicazione le memorizzerà nella cache del cluster, quindi la prossima volta che la tua applicazione proverà a recuperare quelle entità, non farà quel viaggio fino al database back-end, e invece andrà per riportare tali entità dalla cache in cluster nella tua applicazione. Diamo quindi un'occhiata a come funziona questo metodo.

Quindi, se mi avvicino alla mia domanda, qui vado a prendere i miei ordini. Quindi aggiungerò semplicemente alcune opzioni di memorizzazione nella cache degli ordini. Quindi aggiungerò order_caching_options qui e queste saranno "nuove CachingOptions". Quindi specificherò qui il tipo di negozio per dire che voglio recuperare un'unica raccolta di tutti i miei ordini. Quindi StoreAs.Collection e poi popolalo nella mia cache. Inoltre, aggiungerò una scadenza assoluta di 10 minuti a questi dati perché quando hai a che fare con dati transazionali, questi dati cambiano frequentemente, quindi desideri aggiornarli il più regolarmente possibile. Quindi inserirò questa scadenza per 10 minuti in modo che dopo 10 minuti questo set di dati si aggiorni nella cache. Quindi ora aggiungerò il .FromCache() metodo di estensione e aggiungi il mio order_caching_options all'interno, e questo è perfetto. Questo è assolutamente perfetto e questo è tutto ciò che dobbiamo fare.

using OracleEFCore.Models;
using Alachisoft.NCache.EntityFrameworkCore;

namespace OracleEFCore
{
    internal class Program
    {
        static void Main(string[] args)
        {
            using (var context = new Models.ModelContext())
            {
                //-----Orders----- 
                var order_caching_options = new CachingOptions()
                {
                    StoreAs = StoreAs.Collection
                };
                order_caching_options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));

                int upper_orderid = 10300;
                int lower_orderid = 10280;

                var order_resultset = context.Orders
					  .Where(o => o.Orderid >= lower_orderid && o.Orderid <= upper_orderid)
					  .FromCache(order_caching_options)
					  .ToList();
					  ...

Ora andiamo avanti ed eseguiamo l'esempio e diamo un'occhiata a ciò che otteniamo. Perfetto. Quindi l'esempio viene eseguito, non ci sono modifiche qui, quindi posso semplicemente chiuderlo qui e ora possiamo dare un'occhiata a queste richieste che abbiamo nella nostra cache. E possiamo vedere che anche questo conteggio è aumentato. Quindi ora esportiamo le chiavi di cache per questa cache e diamo un'occhiata alla raccolta che abbiamo appena aggiunto nella nostra cache in cluster. Perfetto. Quindi puoi vedere questa raccolta che è stata aggiunta alla cache. È fantastico.

Ma diciamo ora che non volevo mettere una singola raccolta nella cache e volevo invece che ogni ordine fosse un'entità separata. Bene, in tal caso, posso semplicemente specificare il negozio come tipo per essere entità separate.

//-----Orders----- 
var order_caching_options = new CachingOptions()
{
   StoreAs = StoreAs.SeparateEntities
};

Ora, quando eseguo di nuovo questa applicazione, inserirò tutti i miei ordini come entità separate nella cache. Quindi ora che l'applicazione è eseguita, chiudiamola. Possiamo vedere che il conteggio è arrivato al massimo e possiamo vedere queste aggiunte che sono state eseguite e queste richieste. Se vado alle statistiche, possiamo vedere questo conteggio di 7 e questo conteggio di 15. Perfetto.

Ora esportiamo le chiavi della cache e diamo un'occhiata alle chiavi che abbiamo nella nostra cache. Perfetto. Quindi abbiamo queste 22 chiavi o elementi nella nostra cache e tutti i nostri ordini vengono memorizzati nella cache separatamente. Questo riassume più o meno il modo in cui viene utilizzato il metodo di estensione "FromCache()".

Gestione dei dati di riferimento

Ora parliamo di come gestire i dati di riferimento. Pertanto i dati di riferimento sono dati che hanno un caso di utilizzo molto intensivo di lettura ma non vengono aggiornati con la stessa frequenza dei dati transazionali. Un buon esempio di ciò potrebbe essere un catalogo di prodotti. Pertanto, quando hai prodotti in magazzino o un catalogo prodotti, non aggiorni quel catalogo con estrema frequenza. I tuoi prodotti cambierebbero forse una o due volte al mese. Quindi è più probabile che tu legga semplicemente i dati dal database e non aggiorni i dati all'interno del database con estrema frequenza. Quindi ha senso portare i dati dal database in una cache in cluster e quindi leggerli da una cache in cluster in memoria ad alta velocità o da un archivio dati anziché andare al database. E questo fornirà alla tua applicazione prestazioni elevate e scalabilità da caching distribuito in memoria.

Pertanto, quando lavori con dati di riferimento, il primo metodo da utilizzare è il Carica nella cache() metodo. Ora il metodo di caricamento nella cache prende semplicemente i risultati della query eseguita in Entity Framework Core e li memorizza nella cache del cluster. Ora, il metodo di caricamento nella cache può essere impostato per essere eseguito a un intervallo in cui si prevede che i dati vengano aggiornati.

Diciamo, ad esempio, del catalogo prodotti che aggiorniamo ogni settimana. Possiamo impostare questo metodo in modo che venga eseguito ogni settimana in modo che continui ad aggiornare i dati nella cache e che tu abbia sempre dati nuovi presenti nella cache.

Quindi ora che hai l'intero set di dati nella cache diamo un'occhiata al terzo metodo di estensione, che è SoloDallaCache() metodo di estensione. Ora il SoloDallaCache() Il metodo di estensione è un metodo di estensione davvero interessante che fa in modo che tu possa sempre e solo passare dalla tua applicazione alla cache in cluster per recuperare i tuoi dati anziché andare al database back-end. Non andrai mai e poi mai al database supportato quando utilizzi il file SoloDallaCache() metodo di estensione.

Quindi, quando usi questo metodo insieme a Carica nella cache() metodo, hai un set di strumenti davvero potente che assicurano che la tua cache in cluster rimanga aggiornata e sincronizzata con il tuo database e che tu stia recuperando i tuoi dati solo dalla cache in cluster.

Ora diamo un'occhiata a come utilizzeremmo questi metodi. Quindi, quando lavori con questi metodi, la prima cosa che dobbiamo fare è creare qui i nostri indici di query su questi modelli. Se entriamo nel cliente, un modo per farlo è aggiungere il file [QueryIndicizzabile] tag sopra il "Cliente" qui. Quindi, possiamo vedere questo tag "QueryIndexable[]" qui e questo porta in questa libreria. Tuttavia, nel mio caso, non ho bisogno di farlo, quindi lo commenterò semplicemente. Il motivo è che se vado alla mia cache in cluster e ai dettagli, scorriamo verso il basso fino alla scheda degli indici delle query qui e puoi vedere che ho già aggiunto tutti gli indici delle mie query nella cache. Quindi, poiché li ho aggiunti, non ho bisogno di definirli dinamicamente.

Ora che i nostri indici di query sono pronti, ho questo pezzo di codice qui che carica tutti i miei prodotti nella cache dal database. Quindi, andrò avanti e rimuoverò il commento da questo pezzo di codice. Perfetto!

// ------------------------Load ALL Products Into Cache------------------------
...
	var products_caching_option = new CachingOptions
	{
	   StoreAs = StoreAs.SeparateEntities
	};

	products_caching_option.SetAbsoluteExpiration(DateTime.Now.AddDays(10));

	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}"));
	});
...

E tutto ciò che questo codice fa è impostare che voglio inserire i miei prodotti in entità separate e voglio aggiungerli con una scadenza di 10 giorni. Poi questo Carica nella cache() Il metodo sta caricando i prodotti nella cache. Ora eseguiamolo e diamo un'occhiata ai risultati che ottiene. Perfetto! Quindi ora, se scorriamo qui in alto, eccoci qua! Possiamo vedere che abbiamo caricato tutti i prodotti nella cache, questi 77 prodotti.

E poi, se possiamo vedere queste richieste che sono arrivate nella cache, queste aggiunte che sono state eseguite e questo conteggio che è aumentato fino in fondo. Se apriamo le nostre statistiche, possiamo vedere che abbiamo 59 elementi su una partizione e 41 sull'altra.

Ora esportiamo le chiavi della cache e osserviamo i dati che abbiamo. Perfetto! Quindi, abbiamo 100 chiavi nella nostra cache e tutti i prodotti sono stati inseriti nella cache. Perfetto! Quindi, ora che è presente l'intero set di dati, non è necessario eseguire nuovamente questo metodo. Vado avanti e commenterò questo.

E ora eseguiremo il SoloDallaCache() metodo di estensione sulla query dei nostri prodotti che abbiamo eseguito in precedenza. Quindi aggiungo solo '. SoloDallaCache(). Perfetto! E ora, andiamo avanti ed eseguiamo l'esempio e diamo un'occhiata ai risultati di questi recuperi per noi. Perfetto! Quindi, eccoci qui, 26 risultati, gli stessi che abbiamo ottenuto quando abbiamo eseguito questa applicazione senza memorizzazione nella cache, il che significa un risultato completo, e possiamo vedere i recuperi eseguiti e le richieste che abbiamo ricevuto nella cache.

EF Core specifico NCache API

E questo riassume praticamente come puoi usare il file SoloDallaCache() con la Carica nella cache() metodo di estensione. E questo ci porta allo specifico di EF Core NCache API che puoi utilizzare. Quindi, supponiamo ad esempio che tu non voglia utilizzare i metodi di estensione e desideri lavorare con entità indipendenti in cui crei un'entità, la rendi persistente nel contesto e quindi la inserisci nella cache. BENE, NCache ti permette di farlo con il EF Core specifico NCache API. Pertanto, il modo in cui funzionano è recuperare il contesto della cache dal contesto EF Core all'interno dell'applicazione. Quindi, una volta ottenuto il contesto della cache, puoi utilizzarlo per inserire entità nella cache o rimuovere entità dalla cache.

Ora, questo non deve essere confuso con le API fornite nel file NCache SDK. Questi sono specifici di Entity Framework Core e si comportano come dovrebbero con Entity Framework Core. Quindi, nei dati di inserimento, puoi vedere che inseriremo un cliente con una chiave di cache della stringa out. E questa è una chiave di cache fornita dall'API Entity Framework Core.

Ora andiamo avanti e osserviamo come funziona, quindi possiamo vedere come gli elementi o le entità sono persistenti nella cache. Quindi, se scorriamo qui in basso, possiamo vedere che posso aggiungere un cliente alla cache utilizzando l'handle della cache. Quindi, rimuoverò il commento da questo pezzo di codice qui. Perfetto!

//-------------------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
	};

	options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));

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

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

Ora, se vedi che sto semplicemente ottenendo il contesto della cache, sto creando questo cliente qui. Dico che voglio memorizzarlo come entità separata con una scadenza di 10 minuti, qui. Sto semplicemente persistendo nel mio contesto, salvando le modifiche e quindi eseguendo questo inserimento nella cache qui. E poi, stampando che ho aggiunto questo cliente alla cache.

Quindi ora andiamo avanti ed eseguiamo il codice e diamo un'occhiata a come funziona. Perfetto! Quindi, possiamo vedere che il cliente è stato aggiunto alla cache. Lo chiuderò e basta. Possiamo vedere questa addizione per 1 che è stata eseguita e questo aumento nel nostro conteggio. Andiamo quindi alle statistiche. Eccoci qua! Quindi possiamo vederne 41 e il conteggio è passato da 59 a 60.

Ora andiamo avanti ed esportiamo le chiavi della cache. Perfetto! Quindi, eccoci qua! Possiamo vedere il cliente che è stato aggiunto alla cache e puoi vedere che l'API ha assegnato la chiave della cache a questo elemento. Non è stato necessario specificare una chiave per aggiungerlo. Quindi è perfetto!

Ora andiamo avanti, lasciami chiarire questo e rimuoviamo effettivamente questo cliente che abbiamo inserito nella cache. Quindi ora commenterò questo pezzo di codice ancora una volta. Lo commenterò e basta, scorriamo verso il basso e rimuoviamo il cliente utilizzando l'handle della cache. Quindi, ho quel codice qui. Quindi, selezionerò tutto e lo decommenterò proprio qui.

//-------------------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($"\n\nCustomer ID: {customerToRemove.Customerid} -> Removed from Cache");
	}
	else
	{
		Console.WriteLine("\n\ncould not find the customer within the cache");
	}

E ciò che fa questo codice è recuperare nuovamente la cache dal contesto e trovare quel cliente all'interno del contesto. E se quel cliente viene effettivamente trovato, quello che farà è rimuoverlo dal contesto, salvare le modifiche, quindi eseguire questo cache.Remove() per rimuovere il cliente, e poi stamperà che è fatto così. Altrimenti, se non riesce a trovarlo, ci dirà semplicemente che non è riuscito a trovare il cliente nella cache.

Ora andiamo avanti e salviamo questo, eseguiamo questa applicazione e diamo un'occhiata a cosa succede. Perfetto! Quindi, ho trovato il cliente e l'ho rimosso dalla cache. Eccezionale!

Ora chiudiamo e diamo un'occhiata al conteggio e vediamo che è sceso da 60 a 59. Le statistiche mostrano anche che il conteggio è sceso da 60 a 59. Ora esportiamo le chiavi della cache. Dovremmo vedere 100 chiavi ora. Perfetto! Pertanto, non possiamo vedere che il cliente che abbiamo aggiunto in precedenza nel conteggio sia tornato a 100. E questo ci porta praticamente alla fine di questa dimostrazione. Grazie mille per la visione.

Passi successivi

Scaricare NCache

Ora, come parte dei passaggi successivi, ciò che puoi fare è, se desideri scaricare NCache, potrai ottenere una prova gratuita di 30 giorni, che ti darà un prodotto perfettamente funzionante. Puoi farlo andando su alachisoft.com qui e poi andando a scaricare sezione da qui, e qui hai le offerte che puoi scaricare in base alle tue esigenze nella tua versione .NET.

Prova Parco giochi

Puoi prova il NCache parco giochi per 30 minuti. Questo ti offre una sorta di sessione sandbox completa in cui puoi giocare con il codice e vedere come verrebbero eseguiti gli esempi e avere un'idea del prodotto in generale.

Pianifica un appuntamento personalizzato NCache Dimo

Infine, puoi anche programmare un personalizzato NCache dimostrazione dove ti forniremo un dump di un'ora del NCache Caratteristiche e quanto bene funziona. Possiamo anche mappare il tipo di caso d'uso in base ai tuoi punti critici e vedere come funzionerebbe la memorizzazione nella cache nel tuo ambiente. Quindi puoi semplicemente compilare questo modulo qui e inviare la richiesta. Puoi star certo che lo otterremo e programmeremo la demo di conseguenza.

E questo ci porta praticamente alla fine di questa demo. Grazie mille per aver guardato. Buona giornata. Arrivederci.