Les structures de données natives offrent une méthode conventionnelle de stockage et de récupération des données. Grâce à leur implémentation, ils fournissent la simultanéité à vos applications autonomes - ce qui est formidable, sauf qu'ils ne sont limités qu'aux threads à l'intérieur d'un processus d'application. Et avec des applications évolutives exécutées sur plusieurs serveurs, le besoin de partager l'état des structures de données entre les applications se fait sentir.
C'est là qu'interviennent les structures de données distribuées. Tout en offrant la fonctionnalité des structures de données conventionnelles, les structures de données distribuées permettent à plusieurs processus et instances d'application d'ajouter, de récupérer et de supprimer des données simultanément sans compromettre la cohérence des données. Ces structures de données résolvent le problème que les structures de données conventionnelles ne pourraient pas résoudre ; ceux-ci permettent le calcul parallèle.
Où est-ce que NCache s'intégrer?
NCache, étant une solution de mise en cache en mémoire, améliore toutes les fonctionnalités fournies par les structures de données distribuées. En utilisant NCache en tant que cache distribué permet d'accéder à vos données structurées à partir de threads en dehors du processus.
Vous pouvez ajouter vos données dans une structure de données distribuée, les mettre en cache sur l'un des serveurs et vous émerveiller de la façon dont les données sont désormais accessibles à toutes les applications, processus, instances qui font partie de votre système, quel que soit le serveur stocké ces données.
Pour couronner le tout, NCache offre une haute disponibilité sous la forme d'une topologie de réplique partitionnée. Les données que vous conservez dans les serveurs de cache sont tout à fait compréhensibles importantes pour vous. La perte de ces données à cause d'une défaillance du serveur n'est en aucun cas acceptable. C'est exactement pourquoi NCache vous permet de conserver des répliques de vos données dans le serveur de mise en cache afin que si l'un des nœuds tombe en panne, il reste toujours un ensemble répliqué des mêmes données exactes pouvant être utilisées dans de tels scénarios. De cette façon, vous n'aurez jamais de perte de données dans votre application .NET. En plus de tout cela, vous aurez le pouvoir d'ajouter des nœuds de serveur de mise en cache au moment de l'exécution en fonction de vos besoins.
NCache fournit la fonctionnalité de réplication, de partitionnement et de mise à l'échelle des données encapsulées dans les structures de données. Par conséquent, les développeurs utilisant ces structures de données n'ont pas à se soucier de la logique de distribution à l'intérieur de leurs applications .NET.
NCache Détails Structures de données dans NCache
Structures de données distribuées dans NCache
NCache fournit diverses structures de données pour assurer l'évolutivité, la simultanéité et la précision de votre application .NET. Examinons ces structures de données qui améliorent les performances globales de votre application.
Liste distribuée
NCache fournit ListeDistribuée c'est une implémentation .NET native de l'interface IList. NCache être une solution de mise en cache .NET native vous profite également lorsque votre application est uniquement basée sur .NET. Quoi de mieux pour votre application .NET que tout ce qui est natif et hospitalier.
Les extraits de code suivants montrent comment créer, remplir et supprimer une liste distribuée dans NCache.
Une application créant et remplissant une liste :
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); } |
Une autre application récupère et supprime les produits abandonnés de la liste
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); |
Incorporer une liste distribuée dans les applications quotidiennes est très simple. Vous trouverez ci-dessous quelques-uns des scénarios qui décrivent les applications nécessitant une implémentation de liste distribuée.
Cas d'utilisation : panier d'achat
Supposons que votre application .NET soit une plateforme de commerce électronique. Dans cette application, les clients peuvent ajouter et supprimer des articles dans et depuis le panier. Pour permettre à ces demandes d'être traitées en conséquence, vous devez enregistrer les données de chaque client qui contiennent l'identité du client et les éléments qui sont ajoutés ou supprimés par rapport à cet identifiant. Le moyen le plus efficace et le plus organisé consiste à utiliser une liste distribuée.
Une liste distribuée, dans un environnement multi-serveurs, sauvegarde les données de vos clients et les rend disponibles sur tous les serveurs. Vous pouvez faire en sorte que cette liste garde une trace de tous les articles qu'un client a achetés, a montré de l'intérêt ou même ceux qu'il a choisi d'ignorer. Cela améliore non seulement la valeur globale de votre application en conservant un enregistrement sophistiqué, mais rend également les données hautement disponibles pour vous.
Cas d'utilisation : Classement
Pour les personnes intéressées par les jeux, le classement constitue une source d'informations vitale, qu'il s'agisse de jeux en ligne ou de matchs mondiaux. Ces personnes sont toujours intéressées à savoir quelle équipe est en tête et qui est à la traîne. De telles informations peuvent être incorporées dans une application qui utilise une structure de données de liste pour stocker les données requises et les diffuser à tous les utilisateurs intéressés.
NCache Détails Listes dans NCache
File d'attente distribuée
NCache fournit une implémentation premier entré, premier sorti connue sous le nom de File d'attente distribuée. Les files d'attente sont utilisées lors de l'exécution pour stocker des informations précieuses en raison de leur comportement FIFO.
IDistributedQueue est une structure de données facile à comprendre et à mettre en œuvre fournie par NCache. Regardez le code ci-dessous pour vous familiariser avec les opérations de base dans une file d'attente, comme la création d'une file d'attente, l'ajout et la suppression de données.
Une application créant et remplissant la file d'attente
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); } |
Une autre application récupère la file d'attente du cache distribué et retire le premier élément de la file d'attente
1 2 3 4 |
IDistributedQueue<Candidate> queue = cache.DataTypeManager.GetQueue<Candidate>("CandidateQueue"); // Remove first item of queue var firstCandidate = queue.Dequeue(); |
Vous trouverez ci-dessous quelques-uns des cas d'utilisation d'une file d'attente distribuée pour vous donner une idée approximative de l'endroit où vous pouvez utiliser une file d'attente et des avantages que vous allez en retirer.
Cas d'utilisation : file d'attente de messages
Votre application .NET hébergée sur plusieurs serveurs divertissant plusieurs clients à la fois doit envoyer des messages à l'un des clients qui utilisent votre application. Que faites-vous ici? Dans un environnement distribué, vous ne contrôlez pas la connexion entre vos serveurs et les clients, ce qui signifie que vous ne savez pas quel serveur reçoit quel client.
Dans un tel scénario, vous avez besoin d'une file d'attente distribuée pour suivre tous les messages qui doivent être remis aux clients. Cette liste est répartie entre tous les serveurs de cache pour s'assurer que tous les clients connectés à votre application ont accès aux mêmes données à tout moment. NCache s'occupe pour vous de la réplication des données distribuées. Par conséquent, en utilisant une file d'attente distribuée dans un cache distribué, vous pouvez obtenir la simultanéité des données et une haute disponibilité.
Cas d'utilisation : analyse des sentiments
Une application utilisée par une agence de renseignement pour filtrer les tweets menaçants ou confidentiels pourrait totalement bénéficier d'une file d'attente distribuée fournie par NCache. Supposons que plusieurs nœuds exécutent votre application Web. Ce que vous voulez, c'est traiter ces tweets dans un environnement distribué avec une précision telle qu'un tweet ne soit pas traité plus d'une fois. Le moyen d'y parvenir est que cette application utilise une file d'attente distribuée pour stocker tous les tweets entrants. Cela garantira qu'aucun tweet ne sera traité deux fois, améliorant ainsi les performances globales et la précision de votre application.
NCache Détails Files d'attente dans NCache
Ensemble de hachage distribué
NCache fournit une implémentation extrêmement rapide et évolutive d'ensembles appelés DistributedHashSetDistributedHashSetDistributedHashSetDistributedHashSetDistributedHashSetDistributedHashSet. HashSet est un type de données non ordonné dont les valeurs sont uniques et distinctives.
Examinons le code ci-dessous pour comprendre comment vous pouvez créer et remplir un HashSet.
Première application remplissant 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"); |
Deuxième application récupérant le hashset et le modifiant
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(); |
Vous pouvez utiliser des HashSets distribués lorsque votre application doit effectuer des opérations sur des données uniques par nature. Voici quelques-uns des scénarios d'applications dont les performances sont améliorées avec l'implémentation de DistributedHashSet.
Cas d'utilisation : suivi des adresses IP
Comme les hashsets ne contiennent pas de valeurs en double, vous pouvez utiliser NCachela mise en œuvre par HashSets distribués pour garder une trace de tous les utilisateurs et visiteurs du site Web. Par exemple, si vous avez une librairie en ligne, HashSets peut vous aider à identifier assez facilement quel utilisateur est intéressé par quels livres et a acheté combien de livres et ainsi de suite.
Cas d'utilisation : analyse des ventes de commerce électronique
Vous pouvez conserver toutes les informations dont vous avez besoin dans un HashSet. Tout ce dont un HashSet a besoin est une valeur unique pour lui attribuer plusieurs valeurs. Par exemple, vous souhaitez garder une trace de tous les utilisateurs qui ont acheté quoi que ce soit sur votre application de boutique en ligne. Vous voulez leurs identifiants et contre chaque identifiant, vous voulez conserver une liste des articles que le client a achetés, des articles qui ont été mis sur la liste de souhaits, des articles qui ont été supprimés de la liste de souhaits. Maintenant que vous avez toutes ces informations dans un ensemble raffiné, vous pouvez effectuer plusieurs opérations dessus avec la plus grande facilité.
NCache Détails Ensembles de hachage dans NCache
Dictionnaire distribué
DistributedDictionaryDistributedDictionary fourni par NCache est une paire clé-valeur qui est une implémentation .NET native de l'interface IDictionary. Un dictionnaire contient une valeur par rapport à une certaine clé et si cette valeur doit être modifiée, vous devez la remplacer.
Vous pouvez utiliser IDistributedDictionary dans NCache pour tenir un registre des produits. Vous pouvez créer et ajouter/supprimer des informations produit vers et depuis un dictionnaire des manières suivantes.
Première application créant et alimentant un dictionnaire
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); } |
Deuxième application récupérant et modifiant le dictionnaire
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 dictionnaire distribué peut être utilisé dans plusieurs cas, se révélant extrêmement pratique et efficace dans chacun d'eux. Des exemples de tels cas sont fournis ci-dessous.
Cas d'utilisation : stocker des valeurs chiffrées dans le cache
L'un des nombreux avantages de l'utilisation d'un dictionnaire dans un environnement distribué est lorsque vous avez besoin de stocker des clés cryptographiques. Ces clés doivent être disponibles pour tous les serveurs qui font partie de ce système distribué. Vous stockez les données chiffrées dans l'un des serveurs de cache en tant que valeur de dictionnaire avec sa clé de déchiffrement. Faire une telle chose permet à tous les serveurs qui pourraient avoir besoin de ces données à l'avenir d'avoir un accès partagé non seulement aux données mais aussi à sa clé de déchiffrement.
Cas d'utilisation : stockage des identifiants de connexion
Un dictionnaire distribué est le moyen le plus efficace de stocker et d'accéder à l'ID de connexion et au mot de passe d'un utilisateur. Supposons qu'une application s'exécutant sur plusieurs serveurs nécessite que ses utilisateurs fournissent des informations d'identification de sécurité pour pouvoir accéder aux données sensibles. Pour vous assurer que tous les serveurs qui traitent votre application ont accès à ces informations importantes, vous pouvez mettre ces valeurs en cache sous forme de paires clé-valeur de dictionnaire. Cela garantit que si un serveur ajoute une nouvelle paire clé-valeur au dictionnaire, tout autre serveur peut facilement rechercher dans le dictionnaire les données requises.
NCache Détails Dictionnaire en NCache
Compteur distribué
NCache fournit Compteur structure de données utilisée pour incrémenter et décrémenter facilement la valeur. Pour rendre votre vie bien meilleure, NCache vous permet de verrouiller les données placées à l'intérieur d'un compteur pour assurer la cohérence des données.
Pour votre application .NET, le code suivant vous aide à comprendre comment créer une instance ICounter, la remplir avec des données et comment incrémenter/décrémenter cette valeur.
Première application créant le compteur avec une valeur initiale
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); |
Deuxième application récupérant et modifiant le compteur
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(); |
Vous pouvez utiliser des compteurs dans d'innombrables scénarios, il vous suffit de regarder autour de vous et presque tous les problèmes que vous rencontrez peuvent être résolus en utilisant des compteurs distribués dans un environnement de mise en cache. Certains de ces scénarios sont les suivants.
Cas d'utilisation : nombre de pages vues
Pour voir combien de vues une page Web obtient par heure ou par jour, selon ce que vous voulez, cela pourrait facilement être mis en œuvre à l'aide de compteurs distribués dans NCache. À chaque nouvelle vue, le compteur du serveur de cache sera incrémenté en conséquence. Cette valeur ainsi que toutes les valeurs présentes dans tous les serveurs de mise en cache seront mises à jour dans la base de données après un certain laps de temps. Ce faisant, vous évitez de nombreux déplacements inutiles vers la base de données, améliorant ainsi les performances globales de votre application .NET.
Cas d'utilisation : analyse des tweets
Disons que vous avez une application qui compte tous les tweets importants des politiciens et des célébrités. Il garde également une trace du nombre de goûts et d'aversions, de commentaires et de choses que leurs tweets reçoivent. Disons maintenant qu'une personne A les tweets et les likes sur son tweet passent de 0 à un million en moins d'une demi-heure. C'est le genre de données qui ne sont pas transitoires, mais vous devez toujours les conserver. Mais la vitesse à laquelle vous devez persister est beaucoup plus lente que la vitesse à laquelle les données sont mises à jour.
Pour enregistrer un changement aussi abrupt et fréquent, vous avez certainement besoin d'un composant secondaire qui ne laisse pas votre base de données s'étouffer avec la fréquence des données. Et c'est là qu'il faut NCache. Être un cache en mémoire est pratique lorsque vous devez stocker temporairement des informations, puis les écrire toutes dans la base de données après un intervalle. Ici, si vous commencez à mettre en cache le nombre de likes sur Comme tweets au lieu de modifier directement la valeur dans la base de données, vous éviterez de nombreux appels réseau inutiles.
NCache Détails Compteurs dans NCache
Tout résumer
Lorsque vous avez une architecture à un seul niveau, vous n'avez pas du tout besoin de structures de données distribuées. Vous pouvez conserver et implémenter la structure de données dont vous avez besoin dans votre application. Mais, lorsque vous passez à plusieurs serveurs et que vous commencez à traiter des données transitoires qui n'ont pas besoin d'être conservées, ou des données dont la modification est extrêmement coûteuse, votre base de données s'étouffe et les performances sont compromises. Pour éviter qu'une telle tragédie n'arrive à votre application, vous avez besoin de structures de données distribuées. Et quand on parle de distribué, il faut toujours avoir NCache au fond de votre esprit.
NCache est extrêmement évolutif et le fait qu'il s'agisse d'une solution en mémoire en fait la meilleure solution possible pour tous vos problèmes de mise en cache de données.