Le strutture dati native offrono un metodo convenzionale di archiviazione e recupero dei dati. Attraverso la loro implementazione, forniscono concorrenza alle tue applicazioni standalone, il che è fantastico, tranne per il fatto che sono limitate solo ai thread all'interno di un processo di applicazione. E con le applicazioni scalabili in esecuzione su più di un server, sorge la necessità di condividere lo stato delle strutture dati tra le applicazioni.
È qui che intervengono le strutture di dati distribuiti. Pur offrendo la funzionalità delle strutture di dati convenzionali, le strutture di dati distribuiti consentono a più processi e istanze dell'applicazione di aggiungere, recuperare e rimuovere i dati contemporaneamente senza compromettere la coerenza dei dati. Queste strutture dati risolvono il problema che le strutture dati convenzionali non potrebbero risolvere; questi consentono il calcolo parallelo.
Dove si trova NCache inserirsi?
NCache, essendo una soluzione di caching in memoria, migliora tutte le funzionalità fornite dalle strutture di dati distribuite. Usando NCache poiché una cache distribuita consente l'accesso ai dati strutturati da thread esterni al processo.
Puoi aggiungere i tuoi dati in una struttura di dati distribuita, memorizzarli nella cache su uno qualsiasi dei server e meravigliarti di come i dati siano ora accessibili a tutte le applicazioni, i processi, le istanze che fanno parte del tuo sistema indipendentemente da quale server ha memorizzato quei dati.
Ed infine, NCache fornisce disponibilità elevata sotto forma di topologia di replica partizionata. I dati che conservi nei server cache sono comprensibilmente importanti per te. La perdita di questi dati a causa di un errore del server non è comunque accettabile. Questo è esattamente il motivo NCache ti consente di mantenere le repliche dei tuoi dati nel server di memorizzazione nella cache in modo che se uno dei nodi si interrompe, rimane sempre un set replicato degli stessi identici dati che possono essere utilizzati in tali scenari. In questo modo non avrai mai perdite di dati nella tua applicazione .NET. Inoltre, avrai l'autorità per aggiungere nodi del server di memorizzazione nella cache in fase di esecuzione in base alle tue esigenze.
NCache fornisce la funzionalità di replica, partizionamento e ridimensionamento dei dati incapsulati all'interno delle strutture dati. Pertanto, gli sviluppatori che utilizzano queste strutture di dati non devono preoccuparsi della logica di distribuzione all'interno delle loro applicazioni .NET.
NCache Dettagli Strutture dati in NCache
Strutture di dati distribuiti in NCache
NCache fornisce varie strutture di dati per ottenere scalabilità, concorrenza e accuratezza nell'applicazione .NET. Diamo un'occhiata a queste strutture di dati che migliorano le prestazioni complessive della tua applicazione.
Elenco distribuito
NCache fornisce Elenco distribuito che è un'implementazione .NET nativa dell'interfaccia IList. NCache essendo di per sé una soluzione di memorizzazione nella cache nativa .NET ti avvantaggia anche quando la tua applicazione è basata esclusivamente su .NET. Quale cosa migliore per la tua applicazione .NET di tutto ciò che è nativo e ospitale.
I frammenti di codice seguenti mostrano come creare, popolare e depopolare un elenco distribuito in NCache.
Un'applicazione che crea e compila un elenco:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Specify unique cache key for list string key = "ExpensiveProducts"; DataTypeAttributes dataTypeAttributes = new DataTypeAttributes(); dataTypeAttributes.Expiration = new Expiration(ExpirationType.Sliding, new TimeSpan(0, 2, 0)); // Create list of Product type IDistributedList<Product> list = cache.DataTypeManager.CreateList<Product>(key, dataTypeAttributes); // Get products to add to list Product[] products = FetchProductsFromDB(); foreach (var product in products) { // Add products to list list.Add(product); } |
Un'altra applicazione che recupera e rimuove i prodotti fuori produzione dall'elenco
1 2 3 4 5 6 |
// Get list of Product type IDistributedList<Product> list = IDistributedList <Customer> list = cache.DataTypeManager.GetList<Product>("ExpensiveProducts"); // Get range of discontinued products to be removed List<Product> itemsToRemove = FetchDiscontinuedProducts(); list.RemoveRange(itemsToRemove); |
Incorporare un elenco distribuito nelle applicazioni quotidiane è molto semplice. Di seguito vengono forniti alcuni degli scenari che ritraggono le applicazioni che necessitano di un'implementazione di elenchi distribuiti.
Caso d'uso: carrello della spesa
Supponiamo che la tua applicazione .NET sia una piattaforma di e-commerce. In questa applicazione, i clienti possono aggiungere e rimuovere articoli da e verso il carrello. Per consentire l'elaborazione di queste richieste di conseguenza, è necessario salvare i dati di ciascun cliente che contengono l'identità del cliente e gli articoli aggiunti o rimossi rispetto a tale ID. Il modo migliore e più organizzato per farlo è utilizzare un elenco distribuito.
Una lista distribuita, in ambiente multiserver, salva i dati del tuo cliente e li rende disponibili su tutti i server. Puoi fare in modo che questo elenco tenga traccia di tutti gli articoli acquistati da un cliente, per i quali ha mostrato interesse o anche di quelli che ha scelto di ignorare. Ciò non solo migliora il valore complessivo della tua applicazione mantenendo un record sofisticato, ma rende anche i dati altamente disponibili per te.
Caso d'uso: classifica
Per le persone interessate ai giochi, la classifica funge da fonte vitale di informazioni, sia che si tratti di giochi online o partite mondiali. Queste persone sono sempre interessate a sapere quale squadra è in testa e chi è in ritardo. Informazioni come questa possono essere incorporate in un'applicazione che utilizza una struttura di dati a elenco per memorizzare i dati richiesti e trasmetterli a tutti gli utenti interessati.
NCache Dettagli Elenca in NCache
Coda distribuita
NCache fornisce un'implementazione First-in First-out nota come a Coda distribuita. Le code vengono utilizzate in fase di esecuzione per archiviare informazioni preziose a causa del suo comportamento FIFO.
IDistributedQueue è una struttura dati di facile comprensione e implementazione fornita da NCache. Guarda il codice qui sotto per familiarizzare con le operazioni di base in una coda, come la creazione di una coda, l'aggiunta e la rimozione di dati da essa.
Un'applicazione che crea e popola la coda
1 2 3 4 5 6 7 8 9 |
string key = "CandidateQueue"; // Create Queue of Candidate type IDistributedQueue<Candidate> queue = cache.DataTypeManager.CreateQueue<Candidate>(key); foreach(var candidate in candidates) { // Add candidates to queue queue.Enqueue(candidate); } |
Un'altra applicazione che recupera la coda dalla cache distribuita e rimuove dalla coda il primo elemento
1 2 3 4 |
IDistributedQueue<Candidate> queue = cache.DataTypeManager.GetQueue<Candidate>("CandidateQueue"); // Remove first item of queue var firstCandidate = queue.Dequeue(); |
Di seguito sono indicati alcuni dei casi d'uso di una coda distribuita per darti un'idea approssimativa di dove puoi utilizzare una coda e quali vantaggi ne trarrai.
Caso d'uso: coda di messaggi
L'applicazione .NET ospitata su più server che ospita più client contemporaneamente deve inviare messaggi a uno dei client che utilizzano l'applicazione. Cosa fai qui? In un ambiente distribuito, non controlli la connessione tra i tuoi server e i client, il che significa che non sai quale server sta intrattenendo quale client.
In uno scenario di questo tipo, è necessaria una coda distribuita per tenere traccia di tutti i messaggi che devono essere recapitati ai client. Questo elenco è distribuito tra tutti i cache server per garantire che tutti i client connessi alla tua applicazione abbiano sempre accesso agli stessi dati. NCache si occupa per te della replica dei dati distribuiti. Pertanto, utilizzando una coda distribuita in una cache distribuita, è possibile ottenere la concorrenza dei dati e un'elevata disponibilità.
Caso d'uso: analisi del sentimento
Un'applicazione utilizzata da un'agenzia di intelligence per filtrare tweet minacciosi o riservati potrebbe beneficiare totalmente di una coda distribuita fornita da NCache. Supponiamo che ci siano più nodi che eseguono la tua applicazione web. Quello che vuoi è elaborare questi tweet in un ambiente distribuito con tale precisione che un tweet non venga elaborato più di una volta. Il modo per raggiungere questo obiettivo è se quell'applicazione utilizza una coda distribuita per archiviare tutti i tweet in arrivo al suo interno. Ciò assicurerà che nessun tweet venga elaborato due volte, migliorando quindi le prestazioni e l'accuratezza complessive della tua applicazione.
NCache Dettagli In coda NCache
HashSet distribuito
NCache fornisce un'implementazione estremamente veloce e scalabile di insiemi chiamati HashSet distribuito. HashSet è un tipo di dati non ordinato i cui valori sono unici e distintivi.
Diamo un'occhiata al codice seguente per capire come creare e popolare un HashSet.
Prima applicazione che popola un hashset
1 2 3 4 5 6 7 8 9 10 |
// Create unique keys for hashSets string mondayUsersKey = "UsersLoggedInOnMonday"; // Create hashSets of object type IDistributedHashSet<string> userSetMonday = cache.DataTypeManager.CreateHashSet<string>(mondayUsersIds); // Add user IDs for Monday userSetMonday.Add("john_smith"); userSetMonday.Add("mike_cohn"); userSetMonday.Add("mike_ross"); |
Seconda applicazione che recupera l'hashset e lo modifica
1 2 3 4 5 6 |
// Getting hashset from cache IDistributedHashSet<string> userSetMonday = cache.DataTypeManager.GetHashSet<string>("UsersLoggedInOnMonday"); // Remove user with given ID from the set userSetMonday.Remove("mike_cohn"); userSetMonday.RemoveRandom(); |
È possibile utilizzare HashSet distribuiti laddove l'applicazione deve eseguire operazioni su dati unici nella sua natura. Ecco alcuni degli scenari di applicazioni le cui prestazioni sono migliorate con l'implementazione di DistributedHashSet.
Caso d'uso: monitoraggio dell'indirizzo IP
Poiché gli hashset non contengono valori duplicati, puoi utilizzare NCachel'implementazione di HashSet distribuiti per tenere traccia di tutti gli utenti e visitatori del sito web. Ad esempio, se hai un negozio di libri online, HashSets può aiutarti a identificare, abbastanza facilmente, quale utente è interessato a quali libri e ha acquistato quanti libri e quant'altro.
Caso d'uso: analisi delle vendite e-commerce
Puoi conservare tutte le informazioni di cui hai bisogno all'interno di un HashSet. Tutto ciò di cui ha bisogno un HashSet è un valore univoco per assegnare più valori. Ad esempio, vuoi tenere traccia di tutti gli utenti che hanno acquistato qualcosa dalla tua applicazione del negozio online. Vuoi i loro ID e per ogni ID, vuoi mantenere un elenco degli articoli che il cliente ha acquistato, gli articoli che sono stati inseriti nella lista dei desideri, gli articoli che sono stati rimossi dalla lista dei desideri. Ora che hai tutte queste informazioni in un set raffinato, puoi eseguire più operazioni su di esso con la massima facilità.
NCache Dettagli HashSet in NCache
Dizionario distribuito
Dizionario distribuito fornito da NCache è una coppia chiave-valore che è un'implementazione .NET nativa dell'interfaccia IDictionary. Un dizionario contiene un valore rispetto a una determinata chiave e se tale valore deve essere modificato, è necessario sovrascriverlo.
Puoi usare IDistributedDictionary in NCache per tenere un registro dei prodotti. È possibile creare e aggiungere/rimuovere informazioni sul prodotto da e verso un dizionario nei seguenti modi.
Prima applicazione che crea e popola un dizionario
1 2 3 4 5 6 7 8 9 10 11 12 |
string key = "ExpensiveProducts"; // Create dictionary of Product type IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key); // Adding products to dictionary Product[] products = FetchProducts(); foreach(var product in products) { string productKey = $"Product:{product.ProductID}"; dictionary.Add(productKey, product); } |
Recupero e modifica del dizionario della seconda applicazione
1 2 3 4 5 6 7 8 9 10 11 |
// Fetch dictionary of Product type from cache IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.GetDictionary<string, Product>("ExpensiveProducts"); // Create list of keys to remove List<string> keysToRemove = FetchDiscontinuedProducts(); // Get values from dictionary against the given keys ICollection<Product> values = dictionary.Get(keysToRemove); // Remove items from dictionary with given keys int itemsRemoved = dictionary.Remove(keysToRemove); |
Un dizionario distribuito può essere utilizzato in più casi, dimostrandosi estremamente pratico ed efficiente in ciascuno di essi. Esempi di tali casi sono forniti di seguito.
Caso d'uso: archiviazione di valori crittografati nella cache
Uno dei numerosi vantaggi dell'utilizzo di un dizionario in un ambiente distribuito è quando è necessario archiviare le chiavi crittografiche. Queste chiavi devono essere disponibili per tutti i server che fanno parte di quel sistema distribuito. Memorizzi i dati cifrati in uno dei server di cache come valore del dizionario insieme alla sua chiave di decrittazione. Fare una cosa del genere consente a tutti i server che potrebbero aver bisogno di quei dati in futuro di avere accesso condiviso non solo ai dati ma anche alla sua chiave di decrittazione.
Caso d'uso: memorizzazione delle credenziali di accesso
Un dizionario distribuito è il modo più efficiente per archiviare e accedere all'ID di accesso e alla password di un utente. Supponiamo che ci sia un'applicazione in esecuzione su più server che richiede ai suoi utenti di fornire credenziali di sicurezza per poter accedere ai dati sensibili. Per assicurarti che tutti i server che soddisfano la tua applicazione abbiano accesso a queste importanti informazioni, puoi memorizzare nella cache questi valori come coppie chiave-valore del dizionario. Ciò garantisce che se un server aggiunge una nuova coppia chiave-valore al dizionario, qualsiasi altro server può cercare facilmente i dati richiesti nel dizionario.
NCache Dettagli Dizionario in NCache
Contatore distribuito
NCache fornisce Contatore struttura dati che viene utilizzata per incrementare e decrementare il valore con facilità. Per rendere la tua vita molto migliore, NCache ti consente di bloccare i dati inseriti all'interno di un contatore per mantenere i dati coerenti.
Per la tua applicazione .NET, il codice seguente ti aiuta a capire come creare un'istanza di ICounter, popolarla con i dati e come incrementare/diminuire tale valore.
Prima applicazione che crea il contatore con un valore iniziale
1 2 3 4 5 6 7 8 |
string key = "SubscriptionCounter"; long initialValue = 15; // Create counter ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue); // Set the initial value of counter to 100 counter.SetValue(100); |
Seconda applicazione recupero e modifica del contatore
1 2 3 4 5 6 7 8 |
// Create counter ICounter counter = cache.DataTypeManager.GetCounter("SubscriptionCounter"); // Increment value of counter counter.Increment(); // Decrement value of counter counter.Decrement(); |
Puoi utilizzare i contatori in innumerevoli scenari, devi solo guardarti intorno e quasi tutti i problemi che trovi possono essere risolti utilizzando contatori distribuiti in un ambiente di memorizzazione nella cache. Alcuni di questi scenari sono i seguenti.
Caso d'uso: Conteggio visualizzazioni di pagina
Per vedere quante visualizzazioni ottiene una pagina Web all'ora o al giorno, a seconda di ciò che desideri, potrebbe essere facilmente implementato utilizzando contatori distribuiti in NCache. Ad ogni nuova visualizzazione, il contatore nel server della cache verrà incrementato di conseguenza. Questo valore insieme a tutti i valori presenti in tutti i server di cache verrà aggiornato nel database dopo un certo periodo di tempo. In questo modo, si evitano molti viaggi non necessari al database, migliorando quindi le prestazioni complessive dell'applicazione .NET.
Caso d'uso: analisi dei tweet
Diciamo che hai un'applicazione che tiene il conto di tutti i tweet importanti di politici e celebrità. Tiene anche traccia del numero di Mi piace e Non mi piace, commenti e cose che ricevono i loro tweet. Ora diciamo che una persona A i tweet e i Mi piace sul suo tweet passano da 0 a un milione in meno di mezz'ora. Questo è il tipo di dati che non è transitorio ma è comunque necessario mantenerli. Ma la velocità su cui è necessario persistere è molto più lenta della velocità con cui i dati vengono aggiornati.
Per registrare una modifica così brusca e frequente, è sicuramente necessario un componente secondario che non permetta al database di soffocare sulla frequenza dei dati. Ed è qui che ti serve NCache. Essere una cache in memoria è utile quando è necessario archiviare informazioni temporaneamente e quindi scriverle tutte nel database dopo un intervallo. Qui, se inizi a memorizzare nella cache il conteggio dei Mi piace Come tweet invece di modificare direttamente il valore nel database, eviterai molte chiamate di rete non necessarie.
NCache Dettagli Contatori in NCache
Riassumendo tutto
Quando si dispone di un'architettura a livello singolo, non sono necessarie strutture di dati distribuite. Puoi mantenere e implementare qualsiasi struttura di dati di cui hai bisogno all'interno della tua applicazione. Tuttavia, quando ci si sposta su più server e si inizia a gestire dati transitori che non devono essere persistenti o dati la cui modifica è estremamente costosa, il database si blocca e le prestazioni vengono compromesse. Per evitare che una tale tragedia accada alla tua applicazione, hai bisogno di strutture di dati distribuite. E quando parli di distribuito, dovresti sempre averlo NCache in fondo alla tua mente.
NCache è estremamente scalabile e il fatto che si tratti di una soluzione in memoria la rende la migliore soluzione possibile per tutti i problemi di memorizzazione nella cache dei dati.