NCache come ormai sappiamo, memorizza i dati nella cache per prestazioni migliori e ottenere prestazioni e scalabilità elevate. Abbiamo visto NCache facendo miracoli quando si tratta di un rapido accesso ai dati per aumentare le prestazioni della tua applicazione, tuttavia, dobbiamo ancora imparare che tipo di dati fa NCache memorizzare nella cache. Come i database, NCache ti consente di aggiungere dati seguendo semplici passaggi ed è molto flessibile quando si tratta di aggiunta di dati e fornisce una serie di tipi di dati che soddisfano quasi ogni tipo di esigenza dell'applicazione. Questo blog è tutto sulle forme in cui NCache memorizza i tuoi dati nel cache-store fornendoti la massima facilità.
Coppie chiave-valore
Per cominciare, NCache è un negozio di valori chiave che lo afferma chiaramente NCache memorizza i dati in modo tale che ci sia una chiave per quel valore. UN chiave è un identificatore basato su stringa e ha un seguente elenco di proprietà:
- Una chiave dovrebbe essere unica e non è consentita la duplicazione della chiave NCache.
- Una chiave non può essere nulla.
- La chiave fa distinzione tra maiuscole e minuscole.
A APPREZZIAMO è il valore dell'oggetto memorizzato nella cache. In seguito esamineremo tutti i tipi supportati nel blog. Questo spiega la coppia chiave-valore in cui la chiave viene utilizzata come attributo di identificazione per il valore memorizzato su di essa. La figura 1 illustra come i dati vengono aggiunti e archiviati nella cache:
Tipi di dati supportati in NCache
NCache supporta i dati sotto forma di oggetti. Questi oggetti possono essere in una delle seguenti forme:
- tipi primitivi
- Oggetto di classe personalizzato
- Strutture dati
- Dati JSON
Chiavi della cache e panoramica dei dati Aggiunta di dati alla cache NCache Clustering dinamico
Tipi di dati primitivi
NCache supporta tutti i tipi di dati primitivi .NET. È possibile aggiungere una stringa come valore rispetto a una chiave. Di seguito sono riportati i tipi supportati da NCache:
byte/sbyte | corto/corto | oggetto | stringa | doppio | bool | Intervallo di tempo |
int/uint | lungo/lungo | serbatoio | galleggiante | decimale | Appuntamento |
Esaminiamo rapidamente un breve esempio di codice che mostra l'aggiunta di una stringa alla chiave nella cache:
1 2 3 4 5 6 7 8 |
// Specify the customer name as string string customerName = "John Wick"; // Generate a unique cache key string key = "Customer"; // Add the string to cache cache.Add(key, customerName); |
Oggetto di classe personalizzato
L'oggetto di classe personalizzato si riferisce a un oggetto di classe .NET o Java, ad es. Prodotti o Ordini o Clienti ecc. L'unica e molto importante condizione per aggiungi un oggetto di classe personalizzato nella tua cache è contrassegnare i dati serializzabile. Puoi serializzare la classe nella cache in uno dei seguenti modi:
- Aggiunta dell'attributo .NET Serializable nella classe personalizzata o
- utilizzando Serializzazione compatta dinamica questo è un quadro fornito da NCache fornendo una serializzazione economicamente vantaggiosa per le classi registrate in modo dinamico.
Tuttavia, i dati non serializzati non possono essere aggiunti alla cache. Guarda al serializzazione sezione per maggiori dettagli sulla serializzazione dei dati della cache.
Aggiungiamo un oggetto di classe personalizzato nella cache nel codice seguente. Prima di aggiungere i dati alla cache, contrassegnali come serializzati come mostrato:
1 2 3 4 5 6 7 8 |
[Serializable] public class Product { public int ProductID { get; set; } public string ProductName { get; set; } public string Category { get; set; } public int Price { get; set; } } |
1 2 3 4 5 6 7 8 |
// Get product from database against given product ID Product product = FetchProductFromDB(1001); // Generate a unique cache key for this product string key = $"Product:{product.ProductID}"; // Add Product object to cache CacheItemVersion version = cache.Add(key, product); |
Strutture dati
NCache essere distribuito in natura offre la funzionalità di strutture dati convenzionali che consente l'aggiunta, la rimozione e il recupero dei dati senza influire sulla coerenza dei dati. Di seguito sono riportate le strutture dati supportate da NCache:
- Elenco distribuito: Implementazione nativa .NET dell'interfaccia IList. Ad esempio, su una piattaforma di e-commerce, i clienti possono aggiungere/rimuovere articoli utilizzando a lista distribuita.
1 |
IDistributedList list = cache.DataTypeManager.CreateList(key, dataTypeAttributes); |
- Coda distribuita: L'implementazione FIFO (first-in-first-out) per elementi noti come Distributed Queue. Ad esempio, l'analisi del sentiment eseguita da un'agenzia di intelligence per filtrare i tweet minacciosi può utilizzare a coda distribuita per memorizzare i tweet al suo interno.
1 |
IDistributedQueue queue = cache.DataTypeManager.CreateQueue(key); |
- Hashset distribuito: Un'implementazione del tipo di dati non ordinata in cui i valori di un insieme sono unici e distintivi. Ad esempio, se hai una libreria online, HashSet può aiutarti a identificare quale utente è interessato a quali libri o ha acquistato quanti libri.
1 |
IDistributedHashSet userSetMonday = cache.DataTypeManager.CreateHashSet(mondayUsersIds); |
- Dizionario distribuito: Una coppia chiave-valore che è un'implementazione .NET nativa dell'interfaccia IDictionary. Viene mantenuto un valore rispetto a una determinata chiave, ad esempio è possibile memorizzare le credenziali di accesso, ovvero il nome utente e la password sotto forma di dizionario distribuito in un ambiente di cache distribuita.
1 |
IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key); |
- Contatore distribuito: Una struttura di dati utilizzata per aumentare o diminuire facilmente il valore. Ad esempio, per tenere il conto delle visualizzazioni che una pagina web ottiene all'ora o al giorno può essere facilmente implementato utilizzando contatore distribuito.
1 |
ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue); |
Guarda il codice qui sotto per avere un'idea di come usare l'elenco distribuito in NCache dove viene aggiunto un elenco di prodotti nella cache:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// Specify unique cache key for list string key = "ProductList"; // Create list of Product type in cache IDistributedList list = cache.DataTypeManager .CreateList(key); // Get products to add to list Product[] products = FetchProducts(); foreach (var product in products) { // Add products to list list.Add(product); } |
Dati JSON in NCache
JSON è un linguaggio leggibile leggero utilizzato dalle applicazioni per essere estremamente veloce e supportato da tutti i principali framework JavaScript. NCache lasciati aggiungi i tuoi dati JSON facilmente nel cache-store fornendo alcune classi derivate da una classe base JsonValueBase. Diamo un'occhiata alle classi fornite da NCache:
- JsonOggetto: La sezione classe è per coppie nome-valore non ordinate dove name è il nome dell'oggetto e value è il valore dell'oggetto JSON che può essere di qualsiasi tipo primitivo.
- Valore Json: La sezione classe rappresenta i tipi di dati primitivi nelle convenzioni JSON come stringa, intero o DateTime.
- JsonArray: La sezione classe rappresenta una raccolta di elementi e rappresenta JArray in NCachedominio di.
- JsonNull: Questa classe rappresenta il valore NULL negli standard JSON.
Il codice seguente mostra l'utilizzo di JSON in NCache con esempio di codice. L'esempio di codice mostra un JsonObject formato da una stringa e inserito nella cache.
1 2 3 4 5 6 7 8 9 10 11 12 |
var product = GetProductFromDB(); string jsonString = $@"{{ 'ProductID': { product.ProductID}, 'ProductName': '{product.ProductName}', 'Category': '{product.Category}', 'UnitsAvailable' : { product.UnitsAvailable} }}"; JsonObject jsonObject = new JsonObject(jsonString); cache.Insert(key, jsonObject); // Fetch the jsonObject previously added var jsonObject = cache.Get(key); |
Supporto JSON in NCache Strutture di dati distribuiti Aggiunta di dati alla cache
Affinità di posizione
Una caratteristica aggiunta di NCache per fornire prestazioni migliorate è Affinità di posizione. Per ottenere prestazioni più elevate e risultati migliori per la tua applicazione, NCache ti dà il controllo di mantenere i dati di due classi diverse sullo stesso nodo. Ciò crea un'affinità tra diversi articoli appartenenti a classi diverse, risparmiando così il costo corrispondente durante il recupero di quegli articoli. Tutto quello che devi fare è aggiungere gli elementi che hanno un'affinità con parentesi graffe simili {} assicurandoti quindi che gli elementi esistano sullo stesso nodo. Ad esempio, Order_{Product:1001}" mostra l'affinità tra gli ordini appartenenti all'oggetto prodotto con il codice Product Key 1001.
Lascia che ti mostri un esempio di codice in cui Prodotti ed Ordini vengono aggiunti sullo stesso nodo utilizzando l'affinità di posizione.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Product product = FetchProductFromDB(1001); string productKey = "Product:1001"; var productCacheItem = new CacheItem(product); // Add CacheItem to cache CacheItemVersion version = cache.Add(key, productCacheItem); Order order = FetchOrderFromDB(17); // Unique order key for this order using Location Affinity syntax // This will create an affinity for this orderKey with the respective productKey string orderKey = "Order_{Product:1001}"; var orderCacheItem = new CacheItem(order); // Add order with Location Affinity to cache CacheItemVersion version = cache.Add(key, orderCacheItem); |
Conclusione
In conclusione, NCache fornisce modi flessibili per aggiungere dati alla cache in base ai requisiti dell'applicazione. Tutto quello che devi fare è utilizzare una semplice API per aggiungere i dati nella cache. La parte migliore di NCache è che con ogni nuova versione, l'aggiunta di dati diventa più facile ed efficiente con il supporto di nuove funzionalità. Puoi controllare altre fantastiche funzionalità di NCache qui.