I problemi moderni richiedono soluzioni moderne. E la necessità di prestazioni veloci è sempre stata un problema. NCache è una soluzione rapida per problemi critici, come prestazioni e scalabilità. Funziona in modo efficiente e copre tutte le aree problematiche dell'applicazione, sebbene la memorizzazione nella cache abbia il suo scopo principale per le applicazioni ad alta intensità di lettura. Questo blog spiega a fondo come NCache è la scelta migliore per le tue applicazioni ad alta intensità di lettura.
NCache Dettagli Scalabilità in NCache NCache Prestazione
La necessità di memorizzare nella cache
Cominciamo dall'inizio e vediamo perché è necessaria la memorizzazione nella cache? La sua semplice risposta è il tempo di risposta dei database. È un dato di fatto che l'archiviazione principale (il database) contenente tutti i dati in un unico posto può soffocare a causa di un tasso di risposta più elevato. Cosa lo risolve? Caching – in quanto fornisce spazio di archiviazione in memoria e tempi di risposta più rapidi.
In secondo luogo, a differenza di un database, una cache distribuita in natura non ha un singolo punto di errore, il carico è diviso e quindi meno possibilità che le richieste facciano soffocare i server.
Dati i fatti di cui sopra che abbiamo appena discusso, abbiamo stabilito che la memorizzazione nella cache è la soluzione migliore per le situazioni in cui l'intensità di scrittura non è molto alta, ma l'intensità di lettura è relativamente maggiore.
Consideriamo un sito web contenente informazioni sul sistema di trasporto. Le tariffe degli autobus e gli orari sono generalmente statici, il che significa che non cambiano frequentemente. Tali applicazioni con dati ad alta intensità di lettura hanno un ricco set di funzionalità fornite da NCache per eseguire operazioni di lettura più rapide.
NCache Dettagli NCache Per la memorizzazione nella cache dei dati Alta disponibilità
NCache come archivio di cache a uso intensivo di lettura
Le applicazioni con una natura ad alta intensità di lettura, hanno NCache per eseguire tutte le operazioni di lettura il più velocemente possibile. NCache ha un ricco set di funzionalità che soddisfano tutti i tipi di operazioni di lettura come il recupero di articoli singoli o in blocco. Una volta che la cache riceve i dati dal database, tutte le operazioni di recupero passano direttamente alla cache per prestazioni e scalabilità più elevate.
NCache Dettagli Operazioni CRUD Scalabilità in NCache
Entra nelle operazioni NCache
NCache fornisce vari sovraccarichi del Ottenere() metodo per recuperare i dati dalla cache rispetto a una chiave specifica. Queste operazioni sono di natura sincrona e restituiscono un oggetto di tipo sottoposto a cast in base alla logica personalizzata. Nel caso in cui non esista alcun elemento nella cache, restituisce null.
Guarda il codice qui sotto dove un cliente vuole vedere i dettagli dell'indirizzo per assicurarsi che siano corretti usando il normale Ottenere() Metodo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// Pre-condition: Cache is already running // Items are already present in the cache // Initialize Cache ICache cache = CacheManager.GetCache("demoCache"); string customerKey = "Customer:ALFKI"; // Retrieve the Customer object Customer customer = cache.Get<Customer>(customerKey); if (customer != null) { Console.WriteLine($"Customer: {customer.ContactName}, Address : {customer.Address}"); } |
NCache consente anche all'utente di Aggiungi, Aggiornanentoe Rimuovere dati dalla cache.
NCache Dettagli Ottieni operazione Operazioni atomiche
Ottieni oggetti in blocco dalla cache
Allo stesso modo, puoi anche recuperare gli elementi in blocco dalla cache utilizzando il file Ottieni Bulk() metodo. Usando questo, puoi recuperare numerosi elementi dalla cache usando una singola chiamata.
L'esempio seguente mostra come più clienti vengono recuperati dalla cache utilizzando una singola operazione.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Pre-condition: Items are already present in the cache // Create an array of all keys to fetch String[] keys = new String[] { "Customer:ALFKI", "Customer:ANATR", "Customer:ANTON", "Customer:AROUT", "Customer:BERGS" }; // Get items from cache IDictionary<string, Customer> retrievedItems = cache.GetBulk<Customer>(keys); // Retrieve customers and their addresses from dictionary foreach (KeyValuePair<string, Customer> retrievedItem in retrievedItems) { Console.WriteLine($"Customer: {retrievedItem.Value.ContactName}, Address : { retrievedItem.Value.Address}"); } |
Inoltre, NCache fornisce all'utente Aggiungi, inseriree Rimuovere dati in blocco in una singola chiamata.
NCache Dettagli Operazioni CRUD Operazione in blocco
Recupera gli elementi utilizzando le parole chiave
Puoi anche recuperare gli elementi utilizzando le parole chiave allegate per una ricerca efficace. Contrassegni i tuoi dati con determinate parole chiave basate su stringhe e recuperi gli elementi con l'aiuto di queste parole chiave. Ad esempio, desideri raggruppare determinati clienti utilizzando la regione a cui appartengono, come East Coast o West Coast. Il determinato set di funzionalità fornito da NCache a questo scopo è:
Tag con nome | tag | ATTIVITA' E GRUPPI |
---|---|---|
Fornito sotto forma di dizionario | Fornito sotto forma di una matrice di tag | Fornito sotto forma di stringa |
Può essere di qualsiasi tipo di dati primitivo | Solo basato su stringa | Solo basato su stringa |
Nell'esempio riportato di seguito, l'utente desidera visualizzare i dettagli di tutti i clienti che hanno uno sconto dell'abbonamento VIP del 12% utilizzando la query SQL.
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 |
// Pre-conditions: Items are already present in the cache with named tags // Custom class is query indexed through NCache Web Manager or config.ncconf // Create SQL Query with the specified criteria // Make sure to use the Fully Qualified Name for custom class string query = "SELECT CustomerID, ContactName FROM Alachisoft.NCache.Samples.Data.Customer WHERE VIP_Membership_Discount = 0.12"; // Use QueryCommand for query execution var queryCommand = new QueryCommand(query); // Executing Query ICacheReader reader = cache.SearchService.ExecuteReader(queryCommand); // Read results if result set is not empty if (reader.FieldCount > 0) { while (reader.Read()) { // Get the value of the result set string customerID = reader.GetValue<string>("CustomerID"); string customerName = reader.GetValue<string>("ContactName"); Console.WriteLine($"Customer '{customerName}' with ID '{customerID}' has VIP membership discount."); } } else { Console.WriteLine($"No VIP members found"); } |
Per altre operazioni che utilizzano i tag con nome, fare riferimento a NCache Docs.
NCache Dettagli ICacheReader Cerca i dati della cache con tag denominati
Cerca nella cache utilizzando SQL
Per recuperare elementi da un determinato database, le query sono un modo efficace per eseguire ricerche con determinati criteri. NCache comprende appieno la necessità di query, consentendoti di recuperare elementi dalla cache utilizzando simile a SQL interrogazioni. Inoltre, è necessario Index il particolare elemento nella cache in quanto non crea indici da solo, a differenza del database. Ma sei a posto con la query SQL una volta che i dati sono stati indicizzati.
Fornisce API compatibili con ADO.NET come Esegui Lettore, Esegui Scalaree EseguiNonQuery per cercare (SELECT) e rimuovere (DELETE) i dati dalla cache.
Le seguenti sono le cose supportate in NCache interrogazioni:
- Operatori di query di base (=, ==, !=. LIKE, NOT LIKE)
- Operatori logici (AND, OR, NOT)
- Funzioni aggregate (SUM, COUNT, AVG, MIN, MAX)
- Miscellanea
Guarda il codice seguente per vedere come le query di tipo SQL effettuano ricerche nella cache. L'esempio seguente mostra un utente che ha applicato il filtro per mostrare solo i prodotti con prezzo unitario inferiore a 100.
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 |
//Pre-condition: Items are already present in the cache // Use the Fully Qualified Name (FQN) of your own custom class string query = "SELECT * FROM Alachisoft.NCache.Samples.Data.Product WHERE UnitPrice < ?"; // Use QueryCommand for query execution var queryCommand = new QueryCommand(query); // Providing parameters for query queryCommand.Parameters.Add("UnitPrice", 100.0); // Executing QueryCommand through ICacheReader ICacheReader reader = cache.SearchService.ExecuteReader(queryCommand); // Read results if result set is not empty if (reader.FieldCount > 0) { while (reader.Read()) { // Get key of product item in cache string productKey = reader.GetValue<string>("$KEY$"); // Get product attributes string productName = reader.GetValue<string>("ProductName"); double unitPrice = reader.GetValue<double>("UnitPrice"); Console.WriteLine($"Product '{productName}' with key '{productKey}' has UnitPrice {unitPrice}"); } } else { Console.WriteLine($"No product found with price less than 100"); } |
NCache Dettagli Operazioni supportate da SQL Query SQL
Cerca nella cache usando LINQ
Come SQL, NCache fornisce supporto per la scrittura di query in LINQ per cercare nella cache. NCache Il provider LINQ converte Query relative a LINQ ai miglioramenti NCache's esteso SQL e restituisce i risultati di conseguenza dopo averlo trasformato nel formato LINQ. Esistono due tipi di sintassi per la scrittura di query LINQ:
- Espressione lambda
- Espressione di query LINQ semplice
Tuttavia, proprio come SQL, è necessario definire gli indici per i dati della cache ricercabili affinché la query venga eseguita senza problemi.
Guarda l'esempio di codice seguente per vedere come la query LINQ recupera un oggetto dalla cache. L'utente ha applicato il filtro per mostrare bevande o prodotti lattiero-caseari con almeno 10 unità in stock.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// Pre-condition: Items are already present in the cache // Create custom class LINQ object IQueryable<Product> products = new NCacheQuery<Product>(cache); // LINQ query to search cache IQueryable<Product> result = from prod in products where (prod.Category == "Beverages" || prod.Category == "Dairy") && prod.UnitsInStock > 10 select prod; if (result != null) { foreach (Product product in result) { Console.WriteLine($"Product '{product.ProductName}' in Category '{product.Category}' has stock of '{product.UnitsInStock}' units"); } } else { Console.WriteLine($"No product found"); } |
NCache Dettagli Interrogazione LINQ Operatori di base LINQ
Concludendo il Blog
NCache in realtà è una potente soluzione di memorizzazione nella cache per aumentare le prestazioni delle applicazioni ad alta intensità di lettura. Aumenta la velocità e migliora le prestazioni, la scalabilità e l'affidabilità con un ricco set di funzionalità. Si prega di controllare altro NCache Caratteristiche dal nostro sito web.