I database sono stati parte integrante di .NET applicazioni in quanto è possibile recuperare e manipolare grandi set di dati in modo efficiente. Tuttavia, quando si tratta di dati transazionali elevati, i database comportano un degrado delle prestazioni nelle applicazioni .NET. Questo perché i database non possono essere ridimensionati su più macchine: puoi avere solo una macchina server dedicata al livello di database e non puoi aggiungerne altre. Il database diventa così un collo di bottiglia delle prestazioni. Per risolvere questo problema, utilizziamo una soluzione di memorizzazione nella cache distribuita, come NCache per mitigare viaggi inutili e costosi al database.
NCache Dettagli Scaricare NCache Confronto edizione
Come memorizzare nella cache il database?
La memorizzazione nella cache di un database è molto più semplice di quanto sembri. Devi incorporare un livello di memorizzazione nella cache con un tipo di cache NCache tra l'applicazione e il livello di database in modo che i dati del database vengano serviti dalla cache. Per semplicità, sono stati riassunti i quattro modelli più comuni di utilizzo della cache. Sono informati di seguito:
1. Memorizzazione nella cache degli oggetti
Questa strategia suggerisce che se i tuoi dati non esistono nella cache, li prendi dal database e quindi li inserisci nella cache, ad esempio NCache. Le chiamate successive vengono gestite dalla cache in seguito. Per problemi relativi ai dati non aggiornati, aggiungi scadenza Vai all’email elemento della cache in modo che possa essere aggiornato dal database.
La parte di codice seguente recupera un'istanza di Customer dalla cache, se esiste. In caso contrario, lo recupera dal database e lo aggiunge alla cache per un hit nella cache nelle chiamate successive.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
var key = "Customer:1001"; // Get Customer from cache if it exists var customer = cache.Get<Customer>(key); // If customer does not exist in cache if (customer == null) { // Fetch from database customer = GetCustomerFromDB(1001); // Create sliding expiration of 15 seconds. Cache removes item after this time var expiration = new Expiration (ExpirationType.Sliding, TimeSpan.FromSeconds(15.0)); var cacheItem = new CacheItem(customer) { Expiration = expiration }; // Insert the item with expiration into cache cache.Insert(cacheKey, cacheItem); } |
NCache Dettagli Documenti di memorizzazione nella cache dei dati NCache Guida del programmatore
2. Memorizza nella cache i dati di riferimento e utilizza le query SQL per cercarli
I dati solo letti e non modificati frequentemente sono noti come dati di riferimento. È abbastanza comune per un'applicazione .NET leggere ripetutamente dati e scrivere raramente dati nel database. La cache (come NCache) è più potente quando viene utilizzato per i dati di riferimento poiché funziona più velocemente con tali dati.
Si consiglia vivamente di memorizzare nella cache tutti i dati di riferimento e quindi utilizzarli Query SQL per cercare nella cache per questo invece di andare al database. Si noti che se non si memorizza nella cache l'intero set di dati di riferimento (ad es. tutti i clienti), le query SQL sulla cache restituiranno risultati non validi poiché alcuni dei dati sono solo nel database.
Se l'hai già fatto precaricato la cache con tutti i tuoi dati di riferimento, il seguente esempio spiega come cercarlo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// Pre-Requisite: All customer instances have already been added into cache var customerName = "John Smith"; // Write SQL query for cache var query = "SELECT $Value$ FROM Northwind.Model.Customer WHERE Name = ?"; // Create the query command that cache understands from the query var queryCommand = new QueryCommand(query); // Provide the parameters for the query queryCommand.Parameters.Add("Name", customerName); // Execute the query on cache var reader = cache.SearchService.ExecuteReader(queryCommand, true); var customer; // If a valid projection was made in the query if (reader.FieldCount > 0) { while (reader.Read()) { customer = reader.GetValue<Customer>(1); // Perform operation according to business logic } } |
NCache Dettagli Documenti di memorizzazione nella cache SQL Documenti di memorizzazione nella cache dei dati
3. Gestione delle relazioni uno-a-molti nella cache
Per lo più, i nostri dati contengono relazioni tra di loro. Ad esempio, nel contesto del database Northwind (utilizzato da Microsoft), la tabella "Ordini" è correlata alla tabella "Clienti". Queste entità sono considerate entità correlate nel dominio dell'applicazione .NET. Utilizzando una cache come NCache, puoi mettere in relazione queste entità anche all'interno della cache.
Questo è fatto da associare tutte le entità correlate con un identificatore di tag in modo che invece di recuperare ogni ordine dei clienti individualmente, puoi recuperare tutti gli ordini del cliente in un'unica chiamata effettuando una ricerca nella cache tramite l'identificatore del tag. Il codice di esempio fornito illustra come possiamo realizzare questo comportamento:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
var cacheKey = "Customer:1001"; var tagName = "Customer:1001_Orders"; // Check if customer exists in cache var cachedCustomer = cache.Get<Customer>(cacheKey); // If customer does not exist in cache if (cachedCustomer == null) { // Fetch from database var customer = GetCustomerFromDb(1001); // Insert customer into cache cache.Insert(cacheKey, customer); // Fetch orders of the customer from database var relatedOrders = GetRelatedOrdersFromDb(customer); // Create a tag for all orders of the customer var tag = new Tag(tagName); foreach (Order order in relatedOrders) { var orderCacheKey = $"Customer:1001_Order:{order.OrderID}"; // Create a cache item and set the tag identifier var orderCacheItem = new CacheItem(order) { Tags = new[] { tag } }; // Insert the tagged cache item into cache cache.Insert(orderCacheKey, orderCacheItem); } } else { // Item exists in the cache // Create a tag to fetch the related orders var tagIdentifier = new Tag(relatedEntityIdentifier); // Fetch the related orders based on the tag identifier var cachedOrders = cache.SearchService.GetByTag<Order>(tagIdentifier); } |
NCache Dettagli Documenti dati taggati nella cache Documenti di memorizzazione nella cache dei dati
4. Memorizzazione nella cache dei risultati delle query del database (dati transazionali)
Nella maggior parte dei casi, i dati del database vengono restituiti sotto forma di set di risultati di query. Questa strategia suggerisce di inserire l'intero set di risultati nella cache in modo che le query successive vengano servite dalla cache. Le query con gli stessi criteri faranno sempre riferimento allo stesso set di risultati. Pertanto, possiamo considerare i comandi di query stessi come identificatore univoco per il set di risultati e utilizzarlo come chiave nella cache.
La parte di codice seguente mostra come i set di risultati delle query possono essere memorizzati nella cache come raccolte:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// Query to select East Coast Customers var query = "SELECT * FROM Northwind.Model.Customer WHERE Region = ‘EastCoast’"; // Create cache key based on the query var key = query; // Fetch the entities based on query var resultSet = cache.Get<IList<Customer>>(key); // If data against query not found in cache if (resultSet == null) { // Fetch the result set from database var customers = GetCustomersFromDb(query); // Convert the result set into a collection var cacheReadyCustomers = customers.ToList(); // Add result set to cache against query cache.Insert(cacheKey, cacheReadyCustomers); } |
NCache Dettagli Documenti di memorizzazione nella cache dei dati Documenti di memorizzazione nella cache SQL
Conclusione
Come puoi vedere, memorizzare nella cache un database in applicazioni .NET con una cache come NCache è abbastanza facile. In base ai modelli di utilizzo nell'applicazione, puoi memorizzare nella cache i tuoi dati e recuperarli tramite query come se lo facessi per un database.
Per di più, NCache è una soluzione di memorizzazione nella cache distribuita in memoria. Tutti i problemi riscontrati durante l'utilizzo di un database vengono gestiti in esso e dispone di tutte le implementazioni per una cache con requisiti standard e molto altro.