Un cache n'est d'aucune utilité sans les opérations CRUD de base. Étant donné que le cache est un magasin clé-valeur, vous devez ajouter, récupérer ainsi que supprimez données en cache tout le temps. Par conséquent, ces CRUD basés sur des clés (Create, Remove, Update, Delete) ou opérations de base rendent votre cache facile d'accès et d'utilisation.
NCache a été largement adopté pour la mise en cache de données distribuées dans les applications en raison de sa évolutivité linéaire ainsi que la haute disponibilité. NCache fournit diverses API CRUD pour effectuer des opérations de base sur la mise en cache des données. Nous verrons avec quelle facilité vous pouvez utiliser ces opérations dans votre application e-commerce en utilisant NCache pour stocker les données fréquemment utilisées.
NCache Détails Opérations de cache de base Clés et données de cache
Opérations CRUD de base
L'objectif fondamental d'un cache est d'agir comme un magasin de données temporaire pour votre application, donc quelles que soient les données dont vous avez besoin, vous envoyez un ping au cache au lieu de faire un voyage complet vers la base de données. Passons en revue les opérations CRUD de base qui NCache les soutiens. Voici une brève liste de ce que NCache propose:
API | Description | Syntaxe |
Ajouter | Ajoute de nouvelles données au cache | Ajouter (clé, valeur) |
insérer | Met à jour la valeur si la clé existe déjà dans le cache, ou ajoute l'élément comme nouveau sinon | Insérer (clé, valeur) |
Effacer | Supprime la clé spécifiée du cache et renvoie la valeur | Supprimer (clé) |
Obtenez | Récupère la valeur de la clé fournie | Obtenir la clé) |
Mais attendez, ce n'est tout simplement pas un simple magasin clé-valeur. Outre, NCache vous permet également de mettre en cache des objets personnalisés, Objets JSON, structures de données et effectuer des opérations sur eux. Par conséquent, vous disposez d'un stockage complet et d'une plate-forme de réplication pour effectuer des opérations CRUD de base sur toutes sortes de données avec la plus grande flexibilité en utilisant NCache.
NCache prend en charge les opérations synchrones et asynchrones. Opérations synchrones sont cruciaux pour les mises à jour sensibles où vous devez vous assurer que l'opération que vous avez effectuée a bien eu lieu avant de poursuivre. En d'autres termes, de telles opérations sont séquentielles. D'autre part, Opérations asynchrones sont plus flexibles et exécutés en arrière-plan tandis que le contrôle est immédiatement renvoyé au client.
Il est important de noter que, tout NCache Les objets et les API du client SDK sont thread-safe et indépendants les uns des autres. Cela garantit que la réutilisation des instances client est toujours sûre, même entre les threads.
Approfondissons un peu les différents types d'opérations NCache prend en charge pour vous d'effectuer sur vos données de façon transparente. Ici, je vais vous montrer comment jouer avec les opérations de base sur les objets personnalisés.
NCache Détails Opérations de cache de base Clés et données de cache
Types d'opérations dans NCache
NCache permet les opérations CRUD sur un seul élément ou un ensemble d'éléments. Pendant ce temps, les modes de fonctionnement pris en charge sont synchrones et asynchrones. NCache prend en charge les opérations synchrones et asynchrones. Discutons peu en profondeur de différents types d'opérations qui NCache prend en charge, pour que vous puissiez travailler sur vos données en toute transparence.
Opérations atomiques
Toutes les opérations effectuées sur une seule paire clé-valeur sont classées comme opérations atomiques. Par conséquent, de telles opérations nécessitent un appel de cache par élément. En supposant que vous ayez une application de commerce électronique et que vous souhaitiez ajouter un nouveau produit au stock en cache, récupérez et mettez à jour sa valeur, puis supprimez-le du cache avec NCache API CRUD.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// Pre-condition: Cache is already connected // Get product from database var product = GetProductFromDB(1001); string key = $"Product:{product.ProductID}"; // Add item in the cache. Add can be replaced with Insert depending on your requirement. CacheItemVersion version = cache.Add(key, product); // Retrieve cached item from the cache var retrievedItem = cache.Get(key); // Update the price of retrieved product retrievedItem.Price = 500; cache.Insert(key, retrievedItem); // Remove item from the cache cache.Remove(key); |
Il est important de noter que la même clé ne peut pas être ajoutée à nouveau si elle existe déjà dans le cache. Pour cela, vous pouvez utiliser Insert qui écrase la valeur de la clé existante.
NCache Détails Opérations de cache de base Clés et données de cache
Opérations en vrac
Étant donné que vous devrez peut-être effectuer plusieurs opérations simultanément dans votre application, NCache vous permet d'effectuer des opérations CRUD sur un bloc de données en un seul appel. Ces opérations sont conçues pour obtenir de meilleures performances car elles réduisent les appels réseau vers le serveur distant en obtenant le maximum en un seul appel de cache.
Par exemple, si vous souhaitez ajouter, mettre à jour ou supprimer 100 éléments de produit dans le cache, vous pouvez le faire via un seul appel groupé à ajouter, Mise à jour or supprimez ces éléments au lieu d'appeler les API pertinentes 100 fois. Voyons comment vous pouvez utiliser un seul appel groupé pour y parvenir.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// Pre-condition: Cache is already connected // Get products from database Product[] products = FetchProductsFromDB(); IDictionary<string, CacheItem> dictionary = new Dictionary<string, CacheItem>(); foreach (var prod in products) { string key = $"Product:{prod.ProductID}"; var cacheItem = new CacheItem(prod); dictionary.Add(key, cacheItem); } // Inserting items in the cache IDictionary result = cache.InsertBulk(dictionary); // Retrieve items in bulk IDictionary<string, Product> retrievedItems = cache.GetBulk(keys); // Perform business logic here // Remove a chunk of keys from the cache cache.RemoveBulk(keys); |
NCache Détails Opérations de cache de base Clés et données de cache
Opérations synchrones
Les opérations synchrones sont importantes pour les mises à jour sensibles où vous devez vous assurer que l'opération que vous avez effectuée a eu lieu avant de continuer. En d'autres termes, de telles opérations sont séquentielles. Par exemple, vous utiliseriez des opérations synchrones pour mettre à jour les prix de votre stock avant une grande vente afin de vous assurer que les prix ont été mis à jour avec succès.
Ces opérations fonctionnent comme un appel bloquant, où le client doit attendre la réponse du serveur sur l'opération effectuée avant de poursuivre le traitement. Ce qui se passe, c'est que, jusqu'à ce que l'élément soit ajouté (ou qu'une exception soit levée), votre application attend que l'opération soit effectuée pour qu'elle récupère le contrôle. Les opérations CRUD de base sont synchrones par défaut sauf indication contraire.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
// Pre-condition: Cache is already connected // Get product from database var product = GetProductFromDB(1001); string key = $"Product:{product.ProductID}"; // Add CacheItem to cache CacheItemVersion version = cache.Add(key, cacheItem); // Retrieve the cached item from the cache CacheItem retrievedItem = cache.GetCacheItem(key); // Update the price of retrieved product product.Price = 500; retrievedItem = new CacheItem(product); cache.Insert(key, retrievedItem); // Remove item from the cache cache.Remove(key); |
Opérations asynchrones
Les opérations asynchrones sont plus flexibles et exécutées en arrière-plan tandis que le contrôle est immédiatement renvoyé au client. Vous pouvez utiliser cette fonctionnalité dans votre application e-commerce au maximum lorsque des opérations moins critiques comme la mise à jour de la description d'un produit doivent être effectuées. La modification des informations de base n'a pas nécessairement besoin d'être suivie, pas en priorité de toute façon.
NCache prend en charge plusieurs surcharges asynchrones pour effectuer des opérations atomiques. Voyons comment vous pouvez utiliser AddAsync
, InsertAsync
et RemoveAsync
Des API pour ajouter, mettre à jour et supprimer les données de votre application de manière asynchrone.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// Pre-condition: Cache is already connected // Get product from database var product = GetProductFromDB(1001); string key = $"Product:{product.ProductID}"; // Add item in the cache. AddAsync can be replaced with InsertAsync depending on your requirement. Task task = cache.AddAsync(key, product); // Wait before fetching data // Retrieve cached item from the cache var retrievedItem = cache.Get(key); // Update the price of retrieved product retrievedItem.Price = 500; // Add Product object to cache cache.InsertAsync(key, retrievedItem); // Remove item from the cache cache.RemoveAsync(key); |
Conclusion
Puisque vous êtes maintenant familier avec les opérations CRUD de base en NCache, vous pouvez facilement commencer à les utiliser pour améliorer les performances de vos applications distribuées. Ce que vous faisiez avec votre base de données peut maintenant être répliqué simplement dans votre cache et le résultat est une expérience utilisateur améliorée grâce à un temps de réponse considérablement réduit. Tu peux voir le fonctionnalités avancées de NCache pour une utilisation intensive dans vos applications Web, microservices, bibliothèques et applications console. Alors téléchargez NCache maintenant avec son essai gratuit pour en savoir plus !