NCache comme nous le savons maintenant, stocke les données dans le cache pour de meilleures performances et pour obtenir des performances et une évolutivité élevées. Nous avons vu NCache faire des merveilles lorsqu'il s'agit d'accéder rapidement aux données pour l'augmentation des performances de votre application, cependant, nous devons encore savoir quel type de données fait NCache stocker dans le cache. Comme les bases de données, NCache vous permet d'ajouter des données en suivant des étapes simples et est très flexible en ce qui concerne l'ajout de données et fournit un ensemble de types de données qui répondent à presque tous les types de besoins d'application. Ce blog est tout au sujet des formes dans lesquelles NCache stocke vos données dans le cache-store en vous offrant un maximum de facilité.
Paires clé-valeur
Pour commencer, NCache est un magasin clé-valeur qui indique clairement que NCache stocke les données de sorte qu'il existe une clé par rapport à cette valeur. UN key est un identifiant basé sur une chaîne et possède la liste de propriétés suivante :
- Une clé est censée être unique et il n'y a pas de duplication de clé autorisée par NCache.
- Une clé ne peut pas être nulle.
- La clé est sensible à la casse.
A Plus-value est la valeur de l'objet stocké dans le cache. Nous examinerons tous les types pris en charge dans le blog plus tard. Cela explique la paire clé-valeur où la clé est utilisée comme attribut d'identification pour la valeur stockée contre elle. La figure 1 illustre la manière dont les données sont ajoutées et stockées dans le cache :
Types de données pris en charge dans NCache
NCache prend en charge les données sous forme d'objets. Ces objets peuvent se présenter sous l'une des formes suivantes :
- Types primitifs
- Objet de classe personnalisé
- Structures de données
- Données JSON
Présentation des clés de cache et des données Ajout de données au cache NCache Clustering Dynamique
Types de données primitifs
NCache prend en charge tous les types de données primitifs .NET. Vous pouvez ajouter une chaîne en tant que valeur à une clé. Voici les types pris en charge par NCache:
octet/octet | court/ucourt | objet | un magnifique | double | bool | Durée |
int/uint | long/long | carboniser | flotter | décimal | DateTime |
Passons rapidement en revue un bref exemple de code montrant l'ajout d'une chaîne à la clé dans le 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); |
Objet de classe personnalisé
L'objet de classe personnalisé fait référence à un objet de classe .NET ou Java, par exemple des produits ou des commandes ou des clients, etc. La seule condition très importante pour ajouter un objet de classe personnalisé à votre cache est de marquer les données sérialisable. Vous pouvez sérialiser la classe dans le cache soit :
- Ajout de l'attribut .NET Serializable dans votre classe personnalisée ou
- En utilisant Sérialisation compacte dynamique c'est un cadre fourni par NCache fournir une sérialisation rentable pour les classes enregistrées de manière dynamique.
Cependant, les données non sérialisées ne peuvent pas être ajoutées au cache. Regarde le La sérialisation section pour plus de détails sur la sérialisation des données de cache.
Ajoutons un objet de classe personnalisé dans le cache dans le code ci-dessous. Avant d'ajouter les données au cache, marquez-les sérialisées comme indiqué :
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); |
Structures de données
NCache être distribué dans la nature offre la fonctionnalité de structures de données conventionnelles qui permet l'ajout, la suppression et la récupération de données sans affecter la cohérence des données. Voici les structures de données prises en charge par NCache:
- Liste distribuée : Implémentation native .NET de l'interface IList. Par exemple, sur une plate-forme de commerce électronique, les clients qui ajoutent/suppriment des articles peuvent se faire à l'aide d'un liste distribuée.
1 |
IDistributedList list = cache.DataTypeManager.CreateList(key, dataTypeAttributes); |
- File d'attente distribuée : La mise en œuvre du premier entré, premier sorti (FIFO) pour les éléments connus sous le nom de file d'attente distribuée. Par exemple, l'analyse des sentiments effectuée par une agence de renseignement pour filtrer les tweets menaçants peut utiliser un file d'attente distribuée pour y stocker les tweets.
1 |
IDistributedQueue queue = cache.DataTypeManager.CreateQueue(key); |
- Hashset distribué : Une implémentation de type de données non ordonnée où les valeurs d'un ensemble sont uniques et distinctives. Par exemple, si vous avez une librairie en ligne, Ensembles de hachage peut vous aider à identifier quel utilisateur est intéressé par quels livres ou a acheté combien de livres.
1 |
IDistributedHashSet userSetMonday = cache.DataTypeManager.CreateHashSet(mondayUsersIds); |
- Dictionnaire distribué : Une paire clé-valeur qui est une implémentation .NET native de l'interface IDictionary. Une valeur est associée à une certaine clé, par exemple, vous pouvez stocker les identifiants de connexion, c'est-à-dire le nom d'utilisateur et le mot de passe sous la forme d'un dictionnaire distribué dans un environnement de cache distribué.
1 |
IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key); |
- Compteur distribué : Une structure de données utilisée pour incrémenter ou décrémenter facilement la valeur. Par exemple, pour compter les vues qu'une page Web obtient par heure ou par jour peut facilement être mis en œuvre en utilisant compteur distribué.
1 |
ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue); |
Regardez le code ci-dessous pour avoir une idée de la façon d'utiliser la liste distribuée dans NCache où une liste de produits est ajoutée dans le 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); } |
Données JSON dans NCache
JSON est un langage lisible léger utilisé par les applications pour être extrêmement rapide et pris en charge par tous les principaux frameworks JavaScript. NCache te laisse ajoutez vos données JSON facilement dans le cache-store en fournissant quelques classes dérivées d'une classe de base JsonValueBase. Examinons les cours dispensés par NCache:
- JsonObject : Ce classe est pour les paires nom-valeur non ordonnées où nom est le nom de l'objet et valeur est la valeur de l'objet JSON qui peut être de n'importe quel type primitif.
- Valeur Json : Ce classe représente les types de données primitifs dans les conventions JSON telles que chaîne, entier ou DateTime.
- JsonArray : Ce classe représente une collection d'éléments et représente JArray dans NCachele domaine.
- JsonNull : Cette classe représente la valeur NULL dans les normes JSON.
Le code ci-dessous montre l'utilisation de JSON dans NCache avec exemple de code. L'exemple de code montre un JsonObject formé à partir d'une chaîne et inséré dans le 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); |
Prise en charge de JSON dans NCache Structures de données distribuées Ajout de données au cache
Affinité de localisation
Une caractéristique supplémentaire de NCache pour fournir des performances accrues est Affinité de localisation. Pour obtenir de meilleures performances et de meilleurs résultats pour votre application, NCache vous donne le contrôle de conserver les données de deux classes différentes sur le même nœud. Cela crée une affinité entre différents éléments appartenant à différentes classes, économisant ainsi le coût de correspondance lors de la récupération de ces éléments. Tout ce que vous avez à faire est d'ajouter les éléments ayant une affinité avec des accolades similaires {}, garantissant ainsi que les éléments existent sur le même nœud. Par exemple, Order_{Product:1001}" montre l'affinité entre les commandes appartenant à l'objet produit avec la clé de produit 1001.
Laissez-moi vous montrer un exemple de code où Produits ainsi que Mes Commandes sont ajoutés sur le même nœud en utilisant l'affinité de localisation.
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); |
Conclusion
En conclusion, NCache fournit des moyens flexibles d'ajouter des données dans le cache en fonction des exigences de votre application. Tout ce que vous avez à faire est d'utiliser une simple API afin d'ajouter les données dans le cache. La meilleure partie de NCache est qu'à chaque nouvelle version, l'ajout de données devient plus facile et plus efficace grâce à la prise en charge de nouvelles fonctionnalités. Vous pouvez consulter d'autres fonctionnalités intéressantes de NCache ici.