En utilisant NCache dans EF Core et SQL Server

Aujourd'hui, je vais vous montrer comment intégrer NCache dans vos applications Entity Framework Core existantes pour bénéficier des avantages de hautes performances et évolutivité. Il y a beaucoup de choses à couvrir, donc je vais juste y aller directement.

Exemple d’application de base EF

La première chose que nous avons est ceci exemple d'application Entity Framework Core que j'ai et qui utilise des bases de données Northwind SQL. Donc, si nous venons ici, vous pouvez voir que je récupère ces commandes entre ces ID de commande 10249 et 10268, et nous pouvons voir que je récupère ces clients des États-Unis, et ces produits entre ces ID de produit 10 et 20. C'est tout ce que fait cet échantillon. Allons-y et jetons un coup d'œil aux résultats que cela va nous extraire de la base de données. Parfait. Ainsi, nous pouvons voir que nous récupérons ces produits entre 10 et 20, ces 11 produits, ces 13 clients des États-Unis et ces 20 commandes entre ces identifiants de commande.

Maintenant que l'exemple a été exécuté, examinons la base de données avec laquelle nous travaillons. Ainsi, comme vous pouvez le voir, nous travaillons avec les bases de données Northwind, et ce sont les clients que nous avons déjà dans la table de nos clients. Donc, c’est très bien, nous avons vu l’échantillon fonctionner.

Étapes d'intégration

Parlons maintenant de la manière dont nous pouvons intégrer NCache dans cette application Entity Framework Core existante. Nous allons le faire en cinq étapes très simples.

Installer NCache Package Nuget de base EF
Ajouter NCache Espace de noms EntityFrameworkCore
Spécifier les configurations de cache dans DbContext
Rendre les modèles sérialisables
Utilisez NCache Méthodes d'extension de base EF

Installer NCache Package Nuget de base EF

La première étape sera donc d'installer le NCache Package NuGet Entity Framework Core dans l'application. Ainsi, si je gère les packages NuGet pour cette application, nous pouvons voir que j'ai déjà installé EntityFrameworkCore.NCache Package NuGet qui correspond à NCache 5.3 SP2. Parfait. Donc, je vais juste fermer ceci.

Ajouter NCache Espace de noms EntityFrameworkCore

Jetons un coup d'œil à la prochaine étape. La prochaine étape consiste donc à ajouter le NCache Espace de noms Entity Framework Core dans notre application. Donc, si je viens ici, j'ai juste besoin d'ajouter "en utilisant Alachisoft.NCache.EntityFrameworkCore". Je vais devoir faire la même chose pour mon contexte. Donc, je sauvegarde ceci ici, je passe au contexte, et je vais le coller là aussi et le sauvegarder, parfait.

Spécifier les configurations de cache dans le contexte de la base de données

L'étape suivante consiste désormais à spécifier les configurations de cache dans le contexte de la base de données. Maintenant, si je fais défiler vers le bas, je recherche ma méthode « OnConfiguring ». Voilà donc la méthode OnConfiguring. Et, ici, ce que je vais faire, c'est ajouter le cache avec lequel je travaille, c'est donc le « efcorecache » ici, et j'ajoute le «NCacheConfiguration.Configure' et je dis que ce cache et le type de dépendance sont un serveur SQL puisque je travaille avec un serveur SQL, parfait.

Dépendance du cache sur SQL Server

Rendre les modèles sérialisables

Et maintenant que cela est fait, la prochaine étape consiste à rendre nos modèles sérialisables. Donc, je vais juste me diriger vers mes modèles, et je vais aller voir mon client, et je vais juste ajouter [Serializing], parfait. Je vais copier ceci, je vais passer à la commande et le coller là, l'enregistrer, et dans le produit, et je vais juste le coller là, parfait. Donc, maintenant que c'est fait, je vais juste regarder cet employé et vous montrer que j'ai déjà marqué tous les autres modèles comme sérialisables, donc je n'ai plus besoin de faire cela pour d'autres modèles.

Utilisez NCache Méthodes d'extension de base EF

Donc, maintenant que nos modèles sont marqués comme sérialisables, cela nous amène à la cinquième étape. Et la cinquième étape est la plus intéressante. Elle consiste à utiliser le modèle réel. NCache Méthodes d’extension de base d’Entity Framework au sein de notre application. Maintenant, cela dépendra du cas d'utilisation des données existantes dans notre application, et il pourrait s'agir de l'un des deux cas d'utilisation suivants. Nous pourrions soit avoir des données transactionnelles, soit avoir des données de référence dans notre application.

Gestion des données transactionnelles

Donc, si nous parlons de données transactionnelles, et lorsque nous parlons de traitement des données transactionnelles, les données transactionnelles sont les données qui sont censées être lues et écrites extrêmement fréquemment. Un bon exemple de ces données serait de conserver un historique des vols. Donc, il y a beaucoup de vols qui ont lieu au cours d'une journée, et ils ont tous quelque chose de différent, donc si vous les enregistriez dans une base de données, vous écririez constamment de nouveaux vols, et cela peut être considéré comme un cas d'utilisation transactionnel. . Ainsi, lorsque nous avons ce type de cas d'utilisation transactionnel dans nos applications, pour ce type de données, nous disons qu'il est idéal d'utiliser la méthode d'extension « FromCache ».

Maintenant, ce que fait la méthode d'extension FromCache, c'est la première fois que la méthode d'extension FromCache fonctionne, elle fonctionne et se comporte tout à fait comme une application Entity Framework Core normale où vos entités sont récupérées de la base de données. Cependant, à ce stade, la méthode FromCache remplit ces entités dans le cache, et l'avantage est que la prochaine fois que vous devrez appeler ces requêtes, ou que vous aurez besoin de ces entités dans votre application, vous ne reviendrez pas jusqu'au bout. base de données pour obtenir ces entités et, à la place, vous récupérez rapidement ces entités du cache et vous bénéficiez de hautes performances et vous préparez rapidement toutes vos données à être intégrées dans votre application.

Maintenant, allons de l'avant et effectuons cette implémentation et examinons comment cela fonctionne. Donc, pour revenir à notre application, ce que je vais faire ici, c'est que je vais travailler avec les commandes et je vais ajouter quelques options de mise en cache des commandes, c'est parti, et je dis que j'ai de « nouvelles CachingOptions() » ' ici, et je vais juste définir le 'StoreAsType' comme étant une 'Collection'. Je souhaite donc que toutes les commandes soient stockées comme une seule collection dans le cache. Je veux aussi que celles-ci expirent donc, je vais ajouter une expiration donc je vais sur 'SetSlidingExpiration'. Je vais ajouter un 'TimeSpan()' de 10 minutes pour que ces commandes expirent après 10 minutes, parfait . Et maintenant que c'est fait, je vais juste faire défiler vers le bas ici et je vais ajouter la méthode d'extension '.FromCache' et ajouter les 'order_caching_options', parfait. C'est tout ce que j'ai besoin de faire ici.

var order_caching_options = new CachingOptions()
{
	StoreAs = StoreAs.SeparateEntities
};
order_caching_options.SetSlidingExpiration(new TimeSpan(0, 10, 0));

//Orders 
var order_resultset = context.Orders
		     .Where(o => o.OrderId >= 10249 && o.OrderId <= 10268)
		     .FromCache(order_caching_options)
		     .ToList();

Console.WriteLine($"Orders between 10249 and 10268 fetched: {order_resultset.Count}
\n--------------------------------------------------------------------------\n\n"
+ String.Format("{0,-25}  {1,-40}  {2,-10}", $"Order ID", $"Date", $"Shipper Name") + "\n");

order_resultset.ForEach(order =>
{
    Console.WriteLine(String.Format("{0,-25}  {1,-40}  {2,-10}", $"{order.OrderId}", $"{order.OrderDate}", $"{order.ShipName}"));
});

Maintenant, avant de l'exécuter, jetons un œil à notre cache. Maintenant, j'ai ici la configuration « EFCoreCache » sur mes deux nœuds que nous pouvons voir ici. Si vous accédez au moniteur, nous pouvons voir qu'il est entièrement connecté, sain, fonctionnel et en bon état, sans rien à l'intérieur. Et, si nous regardons les statistiques, cela nous raconte la même histoire, c'est une cache saine avec zéro élément à l'intérieur, prêt à l'emploi, parfait. Maintenant, allons de l'avant et exécutons notre application, et jetons un coup d'œil aux résultats que nous obtenons, parfaits.

Maintenant que l'application est exécutée, je vais simplement fermer cette fenêtre de console ici, et nous pourrons voir ces requêtes que nous avons reçues sur notre cache lors de cet ajout qui s'est produit, et si nous faisons défiler vers le bas, nous pouvons voir ce décompte, ce qui signifie que notre collection a été remplie dans le cache.

Maintenant, si je lance les « export-cachekeys », parfait, nous pouvons voir cette collection qui a été entrée dans le cache. Maintenant, disons que je voulais ajouter chaque commande en tant qu'entité distincte, donc ce que je vais faire, c'est ajouter « SeparateEntities » à mon type « StoreAs » au lieu de la collection. Je vais réexécuter cette application. . Et maintenant, ce que cela va faire, c'est qu'au lieu de cette collection unique, cela va ajouter ces commandes en tant qu'entités distinctes. Maintenant que les applications s'exécutent, je peux les fermer et nous pouvons voir toute cette activité qui s'est produite, et plus important encore, ces ajouts. Ces 16 et 4 ajouts, et ce décompte qui a augmenté.

Donc, si nous passons aux statistiques, nous pouvons voir 16 et 5. Maintenant, je vais juste exporter à nouveau les clés de cache, et nous pouvons voir que nous avons un nombre de cache de 21, et toutes nos commandes ont été remplies séparément. entités dans le cache ainsi qu’une collection. Donc, c'est parfait, et cela résume en quelque sorte la façon dont la méthode d'extension FromCache est utilisée.

Gestion des données de référence

Parlons maintenant de la façon dont vous gérez les données de référence et de ce que sont les données de référence. Les données de référence sont le type de données qui sont lues beaucoup plus fréquemment qu'elles ne sont jamais écrites. Ce sont donc des données qui restent plus ou moins assez statiques. Par exemple, vous disposez d’un catalogue de produits. Désormais, vos produits ne sont pas censés changer extrêmement fréquemment, il peut donc s'agir de données de référence qui sont constamment lues à partir de la base de données et qui sont rarement, voire jamais, modifiées. Et, dans le cas de données de référence, il est recommandé de placer l'intégralité de votre ensemble de données de référence dans le cache, puis de ne lire le cache que lorsque vous souhaitez récupérer ces données de référence. Laissez-moi vous montrer comment vous allez procéder.

Ainsi, la première méthode que nous avons, ou la deuxième méthode d’extension que nous avons, est la méthode d’extension « LoadIntoCache() ». Désormais, la méthode d'extension LoadIntoCache() est extrêmement puissante pour charger votre ensemble complet de données de travail dans le cache. Donc, cela va exécuter la requête sur la base de données, il va obtenir le résultat de la requête, remplir l'intégralité du résultat de la requête dans le cache, puis renvoyer ce résultat à l'application.

Et cela est encore une fois utile pour importer les données dans le cache, et vous pouvez l'exécuter à intervalles réguliers chaque fois que vous vous attendez à ce que ces données changent. Ainsi, si vous prévoyez que les données changent dans la semaine, vous pouvez les réexécuter après une semaine pour continuer à actualiser les données dans le cache et pour vous assurer que vous ne recevez pas de résultats partiels lors de l'interrogation uniquement à partir du cache pour ces entités. En parlant d'interrogation uniquement à partir du cache, vous le feriez en utilisant la méthode d'extension 'FromCacheOnly()'. Désormais, la méthode d'extension FromCacheOnly() recherche uniquement les données dans le cache et ne va jamais dans la base de données principale pour obtenir ces résultats. Il s'agit d'une méthode d'extension extrêmement rapide qui garantit que vous bénéficiez de tous les avantages en termes de performances de la mise en cache en mémoire lorsque vous recevez toutes les entités d'un cache clusterisé et que vous ne consultez jamais votre base de données.

Maintenant, allons de l'avant et implémentons ces méthodes d'extension dans notre application. Mais il y a une condition préalable que nous devons remplir avant de les utiliser. Ainsi, pour utiliser ces méthodes d’extension de données de référence, nous devrons définir les index de requête dans notre application, et cela peut être fait de deux manières. Maintenant, je peux créer dynamiquement ces index de requête ici en ajoutant la balise '[QueryIndexable]' qui va également apporter l'espace de noms 'NCache.Runtime.Caching' dans l'application, et maintenant, je l'ai fait de manière dynamique. Mais je vais procéder d'une autre manière. Je vais donc commenter ceci ici, et si je viens sur mes caches de cluster, je peux vous montrer que j'ai déjà défini ces index de requêtes sur mon cache comme nous pouvons le voir ici.

Donc, puisque je l'ai déjà fait, je n'ai pas besoin de les ajouter dynamiquement dans mon application. Donc, maintenant que cela est établi, je vais faire défiler vers le bas et j'ai ce morceau de code ici, et tout ce que cela fait, je vais juste le décommenter, c'est récupérer les produits de la base de données. Il va les stocker en tant qu'entités distinctes en utilisant la méthode d'extension 'LoadIntoCache()', et c'est tout ce que cela va faire. Donc, maintenant, je vais aller de l'avant et exécuter ceci, et jetons un coup d'œil aux résultats que cela obtient, parfaits.

//Load ALL Products Into Cache
var products_caching_option = new CachingOptions
{
    StoreAs = StoreAs.SeparateEntities
};
var all_products = (from products in context.Products
                    select products)
                    .LoadIntoCache(products_caching_option)
                    .ToList();
Console.WriteLine($"\n\nAll Products Loaded into cache : {all_products.Count}\n\n");
all_products.ForEach(product =>
{
    Console.WriteLine(String.Format("{0,-25}  {1,-40}  {2,-10}", $"{product.ProductId}", $"{product.ProductName}", $"{product.UnitPrice}"));
});

Ainsi, nous pouvons voir que ces 77 produits ont été chargés dans le cache, et nous pouvons voir ce nombre qui a augmenté tout en haut, ces ajouts qui ont eu lieu et ces demandes qui sont arrivées. Si nous allons aux statistiques on voit 42 et 57.

Maintenant, je vais juste exporter à nouveau les clés de cache, parfait. Ainsi, nous pouvons voir ces 99 éléments dans notre cache et l'ensemble de notre ensemble de produits de travail a été introduit dans le cache. Maintenant que nous avons l'intégralité de notre ensemble de travail dans le cache, je peux revenir en toute sécurité à l'endroit où j'interrogeais les produits, donc je vais juste commenter ceci, et nous allons monter et nous ' Je vais ajouter la méthode d'extension 'FromCacheOnly()' où je récupérais mes produits, parfait. Et maintenant que cela est fait, je peux simplement relancer l’application. Et jetons un coup d'œil aux résultats que mon application récupère avec cette méthode d'extension 'FromCacheOnly()'. Et voilà.

Ainsi, nous pouvons voir que nous avons obtenu le même nombre de produits, ces 11 produits, donc nous savons que nous avons un résultat complet ici et nous pouvons voir que cette récupération s'est produite depuis notre cache, et cette activité qui signifie que ce FromCacheOnly( ) La méthode d'extension a fonctionné et récupère les résultats pour nous à partir du cache.

Spécifique au noyau EF NCache Apis

C'est donc tout pour les méthodes d'extension FromCacheOnly() et LoadIntoCache(). Maintenant, nous pouvons parler du Spécifique à EF Core NCache Apis. Alors, NCache vous donne la possibilité de ne pas nécessairement utiliser une méthode d'extension pour insérer ou supprimer des données du cache. Vous pouvez également récupérer le handle de cache à partir du contexte à l’aide de la bibliothèque EF Core, puis utiliser ce handle de cache pour insérer des entités indépendantes et supprimer des entités indépendantes du cache. Une chose que j'ajouterais ici, c'est que ce n'est pas la même chose que le NCache API disponibles dans le NCache SDK, et il s'agit de l'API dédiée ou spécifique à Entity Framework Core.

Donc, si nous examinons ces API et comment elles fonctionnent. C’est donc ainsi que nous les utiliserions. Ainsi, nous récupérerions le cache à partir du contexte, puis nous insérerions des données dans le cache en exécutant simplement un cache.Insert sur le client et en fournissant une clé de cache de chaîne de sortie. Cette clé de cache serait générée par les API Entity Framework Core. Et puis, lorsque vous souhaitez supprimer une donnée ou supprimer un élément du cache en utilisant le même handle de cache, vous pouvez, par exemple, rechercher ces données dans le cache à l'aide d'un context.find, puis simplement effectuer un cache.Remove.

Maintenant, allons-y et réalisons-les dans notre application. Donc, si je reviens à mon application ici, et que je vais faire défiler la page vers le bas, j'ai ici ce morceau de code qui ajoute le client au cache. Je vais juste décommenter ce code, et si vous faites défiler vers le haut, nous pouvons voir que j'obtiens simplement le cache du contexte créant ce client, et je souhaite le stocker en tant qu'entité distincte, je souhaite enregistrer les modifications. et effectuez ce cache.Insérez, puis écrivez que j'ai ajouté ce client dans le cache. Alors, allons-y, exécutons-le et jetons un œil à ce que cela fait.

//Add Customer Using Cache Handle
Cache cache = context.GetCache();
var cust = new Customer
{
    CustomerId = "HANIH",
    ContactName = "Hanih Moos",
    ContactTitle = "Sales Representative",
    CompanyName = "Blauer See Delikatessen",
};

var options = new CachingOptions
{
    StoreAs = StoreAs.SeparateEntities
};

context.Customers.Add(cust);
context.SaveChanges(true);

cache.Insert(cust, out string cacheKey, options);
Console.WriteLine($"Customer ID: {cust.CustomerId} -> Added to Cache");

Nous pouvons donc voir que nous avons ajouté ce client dans le cache. Donc, si je ferme cette application, on voit cet ajout qui a été fait à ces requêtes, et on voit une petite baisse, donc on passe de 42 à 43. Si on regarde les statistiques on voit 43 et 57 ce qui complète 100. Donc, si j'exporte les clés de cache, nous pouvons voir ce client indépendant, c'est parti. Ainsi, nous pouvons voir cette entité distincte indépendante que nous avons ajoutée au cache. C'est parfait.

Maintenant, allons-y et supprimons ce client. Donc, je vais juste commenter ce bout de code. Encore une fois, je vais faire défiler vers le bas et décommenter ce morceau de code, et tout ce que fait ce morceau de code, c'est qu'il recherche le client dans le cache du même nom de client, et s'il trouve ce client, c'est je vais le supprimer du contexte, enregistrer les modifications, puis le supprimer du cache. Et puis, il affichera qu'il l'a fait. Sinon, il dira qu'il n'a pas pu trouver le client.

//Remove Customer Using Cache Handle
Cache cache = context.GetCache();
Customer customerToRemove = context.Customers.Find("HANIH");
if (customerToRemove != null)
{
    context.Customers.Remove(customerToRemove);
    context.SaveChanges(true);
    cache.Remove(customerToRemove);
    Console.WriteLine($"Customer ID: {customerToRemove.CustomerId} -> Removed from Cache");
}
else
{
    Console.WriteLine("could not find the customer within the cache");
}
Console.ReadLine();

Alors, allons-y, exécutons cette application et jetons un œil aux résultats, parfaits. Ainsi, nous pouvons voir que le client a été supprimé du cache, et nous pouvons voir dans les statistiques que nous sommes passés de 43 à 42, et le moniteur afficherait la même chose, parfait.

Donc, maintenant, si nous revenons aux statistiques, je vais juste ouvrir le NCache PowerShell, et je vais exporter les clés de cache, parfait. Et nous pouvons voir que nous n’avons plus ce client dans notre cache. Et c'est ainsi que vous pouvez ajouter et supprimer des clients ou des données à l'aide du NCache API spécifiques à EF Core.

Prochaines étapes

Télécharger NCache

Et cela nous amène à la fin de cette démonstration, merci beaucoup. Si tu veux download NCache vous pouvez recevoir un essai gratuit de 30 jours et un produit fonctionnel complet et complet à partir de notre page de téléchargements. Laissez-moi vous y emmener maintenant. Donc, si nous venons ici, vous pouvez voir ici que ce sont les offres pour .NET que vous pouvez télécharger pour Windows et pour Linux qui NCache offre.

Essayez le terrain de jeu

Aussi, vous pouvez essayer NCache dans le NCache Cour de récréation. Et vous pouvez réellement avoir une idée du produit pour voir comment fonctionnent les fonctionnalités. Donc, si vous allez ici au Essayez le terrain de jeu vous pouvez voir que vous pouvez démarrer cette session sandbox pendant 30 minutes, ce qui vous permet d'exécuter des exemples et de voir à quoi ressembleraient les échantillons .NET et Java.

Planifiez un rendez-vous personnalisé NCache Démo

Et enfin, vous pouvez réserver un personnalisé NCache démo où nous vous proposerions une session technique d'une heure où nous discuterions NCache l'architecture et les fonctionnalités, et les cartographier en fonction du cas d'utilisation que nous trouvons au sein de vos environnements. Et pour ce faire, c’est extrêmement simple. Il vous suffit de venir sur notre site Web ici et de planifier cette démo en direct personnalisée à partir de cette page ici. Et, une fois que vous êtes ici, vous pouvez envoyer cette demande, nous la recevrons et nous planifierons quelque chose. Et cela nous amène à la fin de cette démo. Merci beaucoup d'avoir regardé, passez une merveilleuse journée. Au revoir.