Auteur : Iqbal Khan
NCache vous permet de mettre en cache les données plus près de votre application dans le niveau intermédiaire afin de réduire les déplacements coûteux vers la base de données. Cela accélère considérablement votre application. Cela le rend également plus évolutif car la charge sur votre base de données est réduite, ce qui lui permet de gérer un plus grand nombre de clients sans aucune mise à niveau matérielle.
Cependant, lorsque vous mettez des données en cache, vous en créez en fait une copie en dehors de votre base de données. Cela introduit le risque que les données de votre base de données soient modifiées mais que votre copie en cache reste inchangée et devienne obsolète. La bonne nouvelle est que cette situation ne se produit que lorsque plusieurs applications modifient les mêmes données dans la base de données et qu'elles ne mettent pas toutes à jour le cache.
Lorsque vous vous trouvez dans une situation où d'autres applications modifient les données de la base de données et ne mettent pas à jour le cache, vous avez besoin d'un mécanisme permettant au cache de se synchroniser directement avec la base de données. Ceci est possible de plusieurs manières différentes. Si votre base de données est SQL Server 2008/2012, le cache peut utiliser les notifications d'événements .NET pour la synchronisation, ce qui est assez efficace. Mais, si votre base de données est SQL Server 2000, Oracle ou toute autre base de données compatible OLEDB, la seule façon de synchroniser est d'interroger la base de données à la recherche de mises à jour. Cette méthode n'est bien sûr pas aussi efficace car le cache finit par faire de nombreux allers-retours inutiles vers la base de données.
Dans cet article, je vais expliquer comment NCache synchronise le cache avec la base de données SQL Server 2008/2012 à l'aide des notifications d'événements .NET.
Voici ce que vous devez spécifier dans le code de votre application .NET pour utiliser cette fonctionnalité. NCache fournit une interface très similaire à celle de Microsoft SqlCacheDependency interface parce qu'en interne NCache utilise SqlCacheDependency objet à synchroniser avec SQL Server 2008/2012.
public class Program {
public static void Main(string[] args)
{
NCache.InitializeCache("myCache");
Customer cust = new Customer();
cust.CustomerID = "ALFKI";
LoadCustomer(cust);
List<Customer> custList = FindCustomers("San Francisco");
// Do your regular work here...
NCache.Cache.Dispose();
}
// A standard Load method that loads a single row from database
public Customer LoadCustomer(Customer cust)
{
String key = "Customer:CustomerID:" + cust.CustomerID;
Customer cust2 = (Customer)NCache.Cache.Get(key);
if (cust2 != null)
return cust2;
CustomerFactory custFactory = new CustomerFactory();
// Load a single customer from the database
// SELECT * FROM Customers WHERE CustomerID = 'ALFKI'
custFactory.Load(cust);
// Create a SqlCacheDependency for this item
CacheItem item = new CacheItem(cust);
item.Dependency = SqlDependencyFactory.CreateSqlYukonDependency(connectionString,
"SELECT CustomerID FROM Customers WHERE CustomerID = '" + cust.CustomerID + "'");
// Store item in the cache along with SqlCacheDependency
NCache.Cache.Insert(key, item);
return cust;
}
// A query method
public List<Customer> FindCustomers(String city)
{
String key = "List<Customer>:City:" + city;
List<Customer> custList = (List<Customer>)NCache.Cache.Get(key);
if (custList != null)
return custList;
CustomerFactory custFactory = new CustomerFactory();
// Load a list of customers from database based on a criteria
// SELECT * FROM Customers WHERE City = 'San Francisco'
custList = custFactory.FindByCity(city);
// Create a SqlCacheDependency for this list of customers
CacheItem item = new CacheItem(custList);
item.Dependency = SqlDependencyFactory.CreateSqlYukonDependency(connectionString,
"SELECT CustomerID FROM Customers WHERE City = '" + city + "'");
// Store list of customers in the cache along with SqlCacheDependency
NCache.Cache.Insert (key, item);
return custList;
}
}Le code ci-dessus montre deux situations différentes où vous pouvez spécifier SqlCacheDependency. La première est lorsque vous chargez une seule ligne de la base de données, la convertissez en objet et la stockez dans le cache. Dans ce cas, veuillez noter que vous devez spécifier une instruction SQL équivalente que vous avez utilisée dans votre code pour récupérer cette seule ligne. Cette instruction SQL est ensuite utilisée par SqlCacheDependency objet pour établir une connexion avec la base de données et enregistrer les lignes pour lesquelles SQL Server 2008/2012 doit envoyer des notifications d'événements .NET.
La deuxième situation est celle où vous récupérez une collection de lignes de la base de données en tant que collection d'objets, puis stockez la collection entière en tant qu'objet individuel dans le cache. Dans ce cas, vous devez créer un SqlCacheDependency qui utilise la même instruction SQL pour récupérer les mêmes lignes que vous venez de faire à partir de la base de données. Par ici, NCache notifie SQL Server 2008/2012 que lorsque l'une de ces lignes change, une notification d'événement .NET doit être envoyée à NCache.
L'exemple de code ci-dessus couvre la plupart des situations dans lesquelles vous devrez spécifier un SqlCacheDependency dans votre code. Une autre situation est lorsque vous essayez de récupérer une collection d'objets liés au client (par exemple, une relation 1-n). Dans cette situation, vous ferez exactement ce que vous avez fait pour récupérer une collection d'objets Customer. La seule chose qui changerait est l'instruction SQL utilisée pour récupérer les objets associés.
Veuillez noter que l'instruction SQL que vous donnez à CreateSqlYukonDependency() la méthode ne doit pas utiliser "SELECT * ..." format. Vous devez spécifier un ou plusieurs noms de colonne dans le cadre du SELECT déclaration. Autrement, SqlCacheDependency ne fonctionnera pas.
Vous devez activer le Service Broker dans SQL Server 2008/2012 avant NCache pouvez utiliser SqlCacheDependency. Cela permet à SQL Server 2008/2012 d'envoyer des notifications d'événements à NCache pour lui faire savoir que des données ont changé dans la base de données.
ALTER DATABASE Northwind SET ENABLE_BROKER;
GOGardez à l'esprit que NCache appelle automatiquement SqlCacheDependency.Start() méthode depuis son propre code. Vous n'interagissez jamais directement avec SqlCacheDependency et donc pas besoin d'appeler "Start()" méthode dessus.
Vous êtes maintenant prêt à exécuter votre application qui rend NCache appels pour mettre en cache les données. Maintenant, chaque fois que vous cachez quelque chose dans NCache, NCache en informe SQL Server 2008/2012, puis lorsque ces données changent dans SQL Server 2008/2012, il envoie une notification d'événement .NET à NCache. NCache puis supprime ces données du cache car elles ont changé dans la base de données. Ainsi, la prochaine fois que votre application aura besoin de ces données, elle ne les trouvera pas dans le cache et se rendra dans la base de données pour les récupérer, puis les stockera dans le cache.
Comme vous l'avez vu, NCache rend très simple la synchronisation de votre cache distribué avec votre base de données SQL Server 2008/2012. Désormais, vous pouvez avoir l'esprit tranquille en sachant que votre cache n'est jamais désynchronisé avec votre base de données.
Auteur : Iqbal Khan travaille pour Alachisoft , un éditeur de logiciels de premier plan fournissant des solutions de mise en cache distribuée .NET et Java, de mappage O/R et d'optimisation du stockage SharePoint. Vous pouvez le joindre au iqbal@alachisoft.com.