Avec le temps, la mise en cache distribuée devient populaire car elle améliore les performances des applications et offre une évolutivité. Et avec le besoin d'une méthode rapide et évolutive, les gens mettent en cache de plus en plus de données dans le cache. Plus les performances de l'application sont élevées, plus le nombre d'applications clientes est élevé. Cependant, il y a une forte probabilité que votre base de données et le cache soient désynchronisés lorsque plusieurs clients placent et récupèrent des données vers et depuis la source de données. Pour contrer ce problème, la plupart des gens utilisent une technique d'expiration des données appelée durée de vie (TTL) ou Expiration absolue. Cette expiration supprime automatiquement l'élément de cache spécifié après le délai spécifié. Bien qu'il soit populaire, ce mécanisme est une estimation éclairée de la durée pendant laquelle les données restent inchangées dans le cache.
Si vous pensez que vos données ne changeront probablement pas pendant cette durée, ou si vos données ne sont pas très sensibles, ce qui signifie que vous pouvez vous permettre de lire d'anciennes données périmées à partir du cache, vous pouvez utiliser expiration. Mais si vos données sont sensibles pour l'entreprise et que vous ne pouvez pas vous permettre de lire des données inexactes dans le cache, les données obsolètes vous coûteront cher. Dans cette situation, accéder à des données obsolètes est un risque à ne pas prendre.
NCache Détails Types d'expiration des données NCache Docs
Synchronisation NCache avec SQL Server
Pour éviter la situation décrite ci-dessus dans votre application .NET, vous devez vous assurer que votre cache reste synchronisé avec la base de données à tout moment. Et dans ce but précis, NCache vous fournit une fonctionnalité de synchronisation de base de données appelée Dépendance SQL qui vous permet de garder votre cache synchronisé avec la base de données SQL Server. La dépendance SQL utilise les notifications de requête pour synchroniser votre cache avec la base de données en cas de modification des ensembles de données.
NCache Détails Dépendance SQL NCache Docs
Notifications de requête dans SQL Server
Les notifications de requête sont une fonctionnalité de SQL Server qui avertit tous les clients de base de données lorsqu'un jeu de données change dans la base de données. NCache Le serveur utilise cette fonctionnalité pour devenir un client SQL Server et pour s'enregistrer auprès de SQL Server via la dépendance SQL.
De cette façon, SQL Server notifie NCache lorsque des données spécifiques changent dans la base de données. Et NCache conserve un mappage des éléments mis en cache et les ensembles de données correspondants de la base de données. Avec ça, NCache peut invalider l'élément mis en cache, de sorte qu'une nouvelle copie est extraite de la base de données la prochaine fois que l'application en aura besoin.
NCache vous fournit l'API de dépendance SQL via son API client. Cependant, vous devez fournir les paramètres suivants via cette API lors de l'ajout d'éléments mis en cache à NCache.
- Chaîne de connexion: pour établir une connexion avec la base de données.
- TexteCommande: pour déterminer le CommandText utilisé par la dépendance.
NCache Détails Dépendance SQL Configurer l'environnement SQL Server
Sync NCache avec SQL Server : un exemple rapide
Supposons que vous disposiez d'un système d'achat en ligne basé sur .NET avec une gamme d'articles consultables accessibles simultanément par des centaines de clients. Le portail d'achat ouvre le jour de Noël avec une remise de 40% sur l'ensemble du stock. Le serveur d'application met à jour le prix unitaire des produits dans la base de données alors que le cache n'est pas au courant de ce changement.
Si les clients accèdent aux éléments à partir du cache, l'ancienne copie de ces éléments, sans remise, reste disponible. Lorsque les clients recherchent des produits, ils obtiennent les anciens prix unitaires de Noël, ce qui les rend frustrés et mécontents de l'entreprise.
Mais si vous utilisez le NCache fonction de synchronisation de la base de données avec le serveur SQL, l'utilisateur peut activer les notifications pour garder les données synchronisées avec la base de données pour chaque mise à jour. Dans ce cas, l'application n'est pas confrontée à ce problème d'intégrité des données car le cache contient toujours les bonnes données.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
// Creating connection string to get connected with database. string connectionString = "Server=SERVERNAME; Database=NORTHWIND; UserId=USERID; Password=PASSWORD;"; // Getting products from database. List products = FetchProductFromDB(); // Creating dictionary of CacheItems. Dictionary<string, CacheItem> cacheItems = new Dictionary<string, CacheItem>(); foreach(Product product in products) { string productKey = $"Product: {product.ProductID}"; // Creating an SQL dependency on the unit price of product. Whenever the Unitprice changes, the product is removed from the cache. string query = $"Select UnitPrice from dbo.Products where ProductID = {product.ProductID}"; // Creating dependency on all the products. SqlCacheDependency dependency = new SqlCacheDependency(connectionString, query); CacheItem productItem = new CacheItem(product); // Adding Dependency to product item productItem.Dependency = dependency; } // Adding CacheItems in cache cache.Add(productKey, productItem); |
La raison pour laquelle vous devriez utiliser le NCache SqlCacheDependency méthode pour synchroniser les données avec le serveur SQL est simple. Vos données de cache ne deviennent jamais obsolètes et vous pouvez en toute confiance mettre toutes sortes de données et les récupérer sans rencontrer de problèmes d'intégrité des données.
NCache Détails SqlCacheDependency NCache Docs
Recharger automatiquement l'élément de cache via le fournisseur ReadThru
Au lieu d'invalider un élément mis en cache, si vous souhaitez que le cache le recharge automatiquement lorsque ses données correspondantes changent dans la base de données, vous devez implémenter le IReadThruProvider interface dans NCache. Maintenant, chaque fois que NCache reçoit une notification de mise à jour du serveur SQL au lieu de supprimer cet élément du cache, NCache appelle votre fournisseur ReadThru pour récupérer les données mises à jour de la base de données.
Vous ajoutez la ligne de code suivante avant d'insérer des données dans le cache, et NCache gère la synchronisation automatique des données pour vous.
1 2 3 4 5 6 7 8 9 |
// Create a new cache item and add sql dependency to it CacheItem item = new CacheItem(product); item.Dependency = sqlDependency; // Resync if enabled, will automatically resync cache with SQL server item.ResyncOptions = new ResyncOptions(true); // Add cache item in the cache with SQL Dependency and Resync option enabled cache.Insert(key, item); |
NCache Détails Lecture directe des fournisseurs de sources de données NCache Docs
Requêtes paramétrées dans les dépendances SQL
Trop de modifications dans la base de données nécessitent une invalidation fréquente des éléments mis en cache. Pour chaque invalidation de données, une requête SELECT doit être fournie. Et cela signifie que SQL Server doit compiler cette requête SQL avant de l'exécuter. Cela entraîne une dégradation des performances car la compilation des requêtes prend beaucoup de temps.
Pour résoudre ce problème de performances, NCache vous permet d'utiliser des requêtes SQL paramétrées où vous spécifiez des valeurs de paramètre au moment de l'exécution, et ces valeurs changent à chaque exécution. Ici, la requête SQL elle-même est compilée lors de la première exécution et n'a plus besoin d'être recompilée, ce qui permet de gagner beaucoup de temps et d'améliorer les performances.
Pour utiliser des requêtes paramétrées dans votre application, au lieu d'écrire une requête de sélection normale, vous implémentez la requête suivante.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// Creating Param to be passed in stored procedure dictionary. SqlCmdParams paramProductID = new SqlCmdParams { Type = CmdParamsType.Int, Value = product.ProductID }; // Creating stored procedure params. Dictionary<string, SqlCmdParams> parameter = new Dictionary<string, SqlCmdParams>(); parameters.Add("@ProductID", paramProductID); CacheItem productItem = new CacheItem(product); /*Creating an SQL dependency on the unit price of the product. Whenever the unit price changes, the product is removed from the cache*/ SqlCacheDependency dependency = new SqlCacheDependency(connectionString, query, SqlCommandType.Text, parameters); // Adding Dependency to the product item productItem.Dependency = dependency; cache.Add(productKey, productItem); |
NCache Détails SqlCacheDependency SqlCacheDependency
Dépendance SQL basée sur une procédure stockée
De nombreuses organisations préfèrent conserver toutes leurs requêtes SQL utilisées par leurs applications dans leur base de données sous la forme de procédures stockées. Cela améliore les performances car toutes ces procédures stockées sont précompilées et s'exécutent beaucoup plus rapidement que les requêtes SQL dynamiques. Deuxièmement, ils peuvent conserver toutes les requêtes SQL d'accès à la base de données au même endroit et non dispersées dans chaque application, ce qui est difficile à modifier s'ils souhaitent mettre à jour leurs requêtes SQL.
Pour ces organisations, NCache prend en charge la dépendance SQL basée sur une procédure stockée où, au lieu de spécifier une requête SQL dynamique ou même une requête SQL paramétrée, vous pouvez spécifier un appel de procédure stockée.
La requête SQL suivante crée une procédure avec ProductID comme paramètre. Cette procédure stockée peut être utilisée dans votre application pour synchroniser le cache avec la base de données.
1 2 3 4 |
create PROCEDURE sp_GetUnitPriceByProductID @ProductID int as Select UnitPrice from dbo.Products where ProductID = @ProductID; |
Pour appeler cette procédure stockée dans votre application .NET, utilisez l'extrait de code suivant.
1 2 3 4 5 6 7 8 9 10 11 |
// Specifying stored procedure, created in database. string spGetUnitPriceByProductID = "sp_GetUnitPriceByProductID"; /*Creating an SQL dependency on the unit price of product. Whenever the unitprice changes, the product is removed from the cache*/ SqlCacheDependency dependency = new SqlCacheDependency(connectionString, spGetUnitPriceByProductID, SqlCommandType.StoredProcedure, parameters); // Adding Dependency to product item productItem.Dependency = dependency; cache.Add(productKey, productItem); |
NCache Détails Procédures stockées Requête SQL
Conclusion
Si vous n'utilisez pas NCache en tant que source de données principale pour une application basée sur ASP.NET, commencez à l'utiliser maintenant comme :
- NCache est une solution en mémoire qui ne nécessite aucune interférence du client pour rééquilibrer automatiquement les données, ce qui rend votre application extrêmement flexible.
- Il vous permet d'ajouter autant de serveurs que vous le souhaitez lors de l'exécution, vous offrant ainsi la solution la plus évolutive pour votre application .NET.
Si vous avez une application ASP.NET, mais que la base de données que vous utilisez ne prend pas en charge les notifications, NCache vous fournit une méthode appelée dépendance basée sur l'interrogation.