En utilisant NCache dans EF Core avec Oracle

Salut à tous, je m'appelle Sean, et aujourd'hui je vais vous montrer comment vous pouvez intégrer NCache dans votre existant Applications principales d'Entity Framework qui sont configurés avec une base de données Oracle. Nous allons faire cela comme une démonstration pratique où nous allons travailler avec un exemple d'application que j'ai déjà configuré pour cette démo, et nous allons intégrer NCache dans ça. C’est donc quelque chose de très excitant que nous avons prévu. Laissez-moi vous montrer comment nous allons procéder.

Exemple d’application de base EF

Donc, la première chose que j’ai ici est l’exemple d’application lui-même. Donc, vous pouvez voir ici, j'ai l'exemple d'application et je récupère ici des commandes, des clients et des produits. Et je l'ai configuré pour fonctionner avec une base de données Oracle, que je peux vous montrer ici. Si nous allons au contexte, vous pouvez voir que j'ai ici cette méthode UseOracle pour travailler avec ma base de données Oracle.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
   optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}

Donc, avant d'exécuter ce programme, permettez-moi de vous présenter la base de données et de vous montrer avec quoi nous travaillons. Je travaille donc avec la base de données Northwind dans Oracle. Et comme nous avons beaucoup de tables, j'ai ouvert celles avec lesquelles je travaille ici pour que nous puissions les voir. Le premier est ORDERS, et nous pouvons voir ces propriétés ici pour les commandes avec lesquelles nous allons travailler. Ensuite, jetons un coup d'œil à nos PRODUITS. Ce sont donc les propriétés du produit que nous obtiendrons ou récupérerons dans notre application. Et puis, le troisième tableau est CLIENTS, et nous pouvons voir les propriétés de nos clients ici. Et c'est à peu près toutes les tables avec lesquelles nous allons travailler.

Alors maintenant, interrogeons ces tables et examinons ce que nous avons à l'intérieur. Ainsi, vous pouvez voir que j'ai 77 produits dans ma base de données Northwind, et ce sont tous les produits ici. Donc, c'est très bien. Maintenant, jetons un coup d'œil aux CLIENTS, aux clients, et entrons, et si je fais défiler jusqu'en bas, parfait ! Ainsi, nous pouvons voir que j'ai 89 clients dans ma base de données Northwind, et tous ces clients sont ici, comme vous pouvez le voir devant vous.

Jetons maintenant un œil à nos commandes. Maintenant, il va y avoir beaucoup de commandes, faisons défiler vers le bas – parfait ! Nous pouvons donc constater que nous avons 830 commandes dans notre base de données. Cela fait beaucoup de commandes, et nous pouvons voir toutes ces commandes ici. Nous allons donc procéder à une recherche à travers certains critères de la candidature, et nous allons passer en revue cela maintenant.

Alors maintenant que l’application est exécutée, on voit parfaitement. Maintenant, laissez-moi faire défiler vers le haut pour que nous puissions récupérer ces produits entre les ID 25 et 50. Nous avons donc 26 produits ; des clients qui viennent du Royaume-Uni, nous avons donc sept clients ; et des commandes entre 10280 10300 et 21 XNUMX, nous avons donc ces XNUMX commandes – parfait !

Commandes récupérées de la base de données

NCache Configuration pour EF Core

Maintenant que nous savons que l'exemple fonctionne, nous pouvons passer à la configuration NCache dans notre application Entity Framework Core. Donc, configurer notre application pour qu'elle fonctionne avec NCache est aussi simple que cinq étapes que nous allons suivre dans cette démonstration.

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

Commençons donc par la première étape ici, qui consiste à installer le NCache Entity Framework Core NuGet Package dans notre application. Donc, si je me dirige vers les packages NuGet dans mon application, nous recherchons EntityFrameworkCore.NCache Package NuGet, qui se trouve ici. Je l'ai installé dans mon application, nous pouvons donc le voir ici. Et j'utilise la version 5.3.2.1, qui correspond à NCache version 5.3 SP2. Donc c'est parfait. Maintenant, allons de l'avant, fermons cet onglet et passons à l'étape suivante.

Ajouter NCache Espace de noms EntityFrameworkCore

La prochaine étape consiste donc à ajouter le NCache Espace de noms Entity Framework Core dans l’application. Alors, ouvrons à nouveau le code et entrons dans notre programme ici. Et je vais juste ajouter :

using Alachisoft.NCache.EntityFrameworkCore

Parfait! Donc, je vais juste sauvegarder ceci, accéder au contexte du modèle et le coller ici – parfait ! Maintenant que cela est fait, nous pouvons passer à l'étape suivante, qui consiste à spécifier les configurations du cache dans le contexte de la base de données.

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

Donc, je vais faire défiler jusqu'à ma méthode de configuration, et je vais ajouter le nom du cache avec lequel nous allons travailler et je vais passer le NCache configuration. Donc, ça va être mon « efcoreoraclecache » — parfait ! Et je dois ajouter le NCacheConfiguration.Configurer le nom du cache ainsi que le DependencyType, qui sera Oracle — parfait ! Et c'est à peu près tout ce que j'ai à faire ici.

...
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
   string cache = "efcoreoraclecache";

   NCacheConfiguration.Configure(cache, DependencyType.Oracle);

   optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}
...

Jetons maintenant un œil au cache avec lequel nous allons travailler. Vous pouvez donc voir que mon EFCoreOracleCache est configuré ici même sur ces deux machines de démonstration. Et jetons un œil aux détails de cette cache. Donc, à partir de là, si nous voulons surveiller ce cache, nous pouvons cliquer sur ce bouton de surveillance. Cela va nous amener au moniteur ici qui nous montre la santé de notre cache, et nous pouvons voir qu'il est bon et propre, et que nous avons un cache sain avec lequel travailler.

Si nous revenons à nos coordonnées et cliquons sur statistiques, cela nous amènera à cette page ici qui nous montre les statistiques de notre cache. Maintenant, si nous revenons à notre moniteur, revenons à notre application et ouvrons l'étape suivante.

Rendre les modèles sérialisables

La prochaine étape consiste donc à rendre nos modèles sérialisables. Parfait. Alors maintenant, je vais me diriger vers mon modèle client. Donc ça va être là-bas. Parfait. Et je vais juste ajouter [Sérialisable] par ici. Parfait. Alors maintenant que c'est fait, je peux passer à ma commande. Et vous pouvez voir que c'est déjà marqué comme [Sérialisable]. Et mon produit, qui encore une fois est déjà marqué comme [Sérialisable]. Tous mes modèles sont donc sérialisables, et nous sommes prêts à y aller. Nous pouvons donc maintenant passer à l'étape suivante.

Utilisez NCache Méthodes d'extension de base EF

La prochaine étape consiste à utiliser le NCache Méthodes d'extension Entity Framework Core au sein de notre application. Et je vais juste faire une pause ici car les méthodes d'extension que nous choisirons d'utiliser dépendront du type de données que nous mettons réellement en cache.

Il existe donc deux types de données que nous pouvons mettre en cache : le premier type étant transactionnel et le second type étant de référence. Quels sont ces types et comment vous êtes censé les gérer est quelque chose que nous aborderons sous peu. Parlons donc du premier. Parfait.

Gestion des données transactionnelles

Ainsi, le premier type de données que vous pouvez gérer sont les données transactionnelles. Désormais, les données transactionnelles sont des données qui ont un cas d'utilisation intensif en lecture et en écriture. Ainsi, un bon exemple de ceci serait les données de vol où chaque jour vous avez tant de vols et ces données sont écrites dans la base de données chaque jour, et elles sont également extraites de la base de données chaque jour. Il s’agit donc d’un cas d’utilisation très intensif en lecture et en écriture qui qualifie ces données de transactionnelles. Dans notre cas, un cas d'utilisation similaire peut être mappé à nos commandes. Nous pouvons donc considérer nos commandes comme nos données transactionnelles. Ainsi, lorsque nous parlons de gérer les données transactionnelles dans Entity Framework Core avec NCache, nous utiliserons le DepuisCache() méthode d'extension.

Désormais, lorsque vous associez cette méthode d'extension avant vos requêtes existantes, la première fois que vous l'exécuterez, elle s'exécutera comme une requête standard. Votre application va accéder à la base de données et récupérer les entités à partir de là. Cependant, cette fois, votre application va les mettre en cache dans votre cache clusterisé, et donc la prochaine fois que votre application essaiera de récupérer ces entités, elle ne fera pas ce voyage jusqu'à la base de données principale, mais à la place pour ramener ces entités du cache cluster dans votre application. Voyons donc comment fonctionne cette méthode.

Donc si je passe sur mon application, c'est par ici que je récupère mes commandes. Je vais donc simplement ajouter quelques options de mise en cache des commandes. Je vais donc ajouter order_caching_options ici, et ce seront de « nouvelles CachingOptions ». Je vais donc préciser ici mon type de magasin pour dire que je souhaite récupérer une seule collection de toutes mes commandes. Alors StoreAs.Collection, puis remplissez-le dans mon cache. De plus, je vais ajouter une expiration absolue de 10 minutes à ces données car lorsque vous traitez des données transactionnelles, ces données changent fréquemment, vous souhaitez donc les actualiser aussi régulièrement que possible. Je vais donc simplement mettre cette expiration à 10 minutes afin qu'après 10 minutes, cet ensemble de données s'actualise dans le cache. Alors maintenant, je vais ajouter le .FromCache() méthode d'extension et ajoutez mes order_caching_options à l'intérieur, et c'est parfait. C’est absolument parfait et c’est tout ce que nous devons faire.

using OracleEFCore.Models;
using Alachisoft.NCache.EntityFrameworkCore;

namespace OracleEFCore
{
    internal class Program
    {
        static void Main(string[] args)
        {
            using (var context = new Models.ModelContext())
            {
                //-----Orders----- 
                var order_caching_options = new CachingOptions()
                {
                    StoreAs = StoreAs.Collection
                };
                order_caching_options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));

                int upper_orderid = 10300;
                int lower_orderid = 10280;

                var order_resultset = context.Orders
					  .Where(o => o.Orderid >= lower_orderid && o.Orderid <= upper_orderid)
					  .FromCache(order_caching_options)
					  .ToList();
					  ...

Maintenant, allons de l'avant, exécutons l'échantillon et examinons ce que nous obtenons. Parfait. L'exemple est donc exécuté, il n'y a aucun changement ici, je peux donc simplement le fermer ici, et maintenant nous pouvons jeter un œil à ces requêtes que nous avons reçues dans notre cache. Et nous pouvons constater que ce chiffre a également augmenté. Alors maintenant, exportons les clés de cache de ce cache et examinons la collection que nous venons d'ajouter à notre cache cluster. Parfait. Vous pouvez donc voir cette collection qui a été ajoutée au cache. C'est génial.

Mais disons maintenant que je ne voulais pas mettre une seule collection dans le cache et que je voulais plutôt que chaque commande soit une entité distincte. Eh bien, dans ce cas, je peux simplement spécifier le magasin comme type pour être des entités distinctes.

//-----Orders----- 
var order_caching_options = new CachingOptions()
{
   StoreAs = StoreAs.SeparateEntities
};

Désormais, lorsque j'exécuterai à nouveau cette application, elle placera toutes mes commandes en tant qu'entités distinctes dans le cache. Alors maintenant que l'application est exécutée, fermons-la. On voit que le décompte a augmenté au maximum et on voit ces ajouts qui ont été effectués et ces demandes. Si je regarde les statistiques, nous pouvons voir ce décompte de 7 et ce décompte de 15. Parfait.

Maintenant, exportons les clés de cache et examinons les clés que nous avons dans notre cache. Parfait. Nous avons donc ces 22 clés ou éléments dans notre cache, et toutes nos commandes sont mises en cache séparément. Cela résume assez bien 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 pouvez gérer les données de référence. Les données de référence sont donc des données qui ont un cas d'utilisation très intensif en lecture, mais qui ne sont pas mises à jour aussi fréquemment que les données transactionnelles. Un bon exemple serait un catalogue de produits. Ainsi, lorsque vous avez des produits en stock ou un catalogue de produits, vous ne mettez pas à jour ce catalogue très fréquemment. Vos produits changeraient peut-être une ou deux fois par mois. Il est donc plus probable que vous lisiez simplement ces données à partir de la base de données et que vous ne mettiez pas vraiment à jour ces données dans la base de données extrêmement fréquemment. Il est donc logique de transférer ces données de la base de données dans un cache clusterisé, puis de lire ces données à partir d'un cache clusterisé en mémoire à grande vitesse ou d'un magasin de données plutôt que d'accéder à la base de données. Et cela fournira à votre application des performances et une évolutivité élevées depuis mise en cache distribuée en mémoire.

Ainsi, lorsque vous travaillez avec des données de référence, la première méthode que vous utiliserez est la LoadIntoCache() méthode. Désormais, la méthode de chargement dans le cache prend simplement les résultats de la requête que vous avez exécutée dans Entity Framework Core et met ces résultats en cache dans le cache du cluster. Désormais, la méthode de chargement dans le cache peut être configurée pour s'exécuter à un intervalle lorsque vous vous attendez à ce que les données soient mises à jour.

Disons, par exemple, le catalogue de produits que nous mettons à jour chaque semaine. Nous pouvons configurer cette méthode pour qu'elle s'exécute chaque semaine afin qu'elle continue à actualiser les données dans le cache et que vous ayez toujours de nouvelles données présentes dans le cache.

Alors maintenant que vous avez l'ensemble de vos données dans le cache, examinons la troisième méthode d'extension, qui est la FromCacheOnly() méthode d'extension. Maintenant le FromCacheOnly() La méthode d'extension est une méthode d'extension vraiment intéressante qui permet de passer uniquement de votre application au cache cluster pour récupérer vos données plutôt que d'accéder à la base de données principale. Vous n'accéderez jamais à la base de données sauvegardée lorsque vous utilisez le FromCacheOnly() méthode d'extension.

Ainsi, lorsque vous utilisez cette méthode en tandem avec le LoadIntoCache() méthode, vous disposez d'un ensemble d'outils très puissants qui garantissent que votre cache cluster reste à jour et synchronisé avec votre base de données, et que vous récupérez vos données uniquement à partir de votre cache cluster.

Voyons maintenant comment nous utiliserions ces méthodes. Ainsi, lorsque vous travaillez avec ces méthodes, la première chose que nous devons faire est de créer ici nos index de requête sur ces modèles. Si nous entrons dans le client, une façon de procéder consiste à ajouter le [RequêteIndexable] balise au-dessus du « Client » ici. Ainsi, nous pouvons voir cette balise 'QueryIndexable[]' ici, et cela amène cette bibliothèque. Cependant, dans mon cas, je n'ai pas besoin de faire cela, je vais donc simplement commenter cela. La raison en est que si je vais dans mon cache clusterisé et dans les détails, faisons défiler jusqu'à l'onglet index de requête ici, et vous pouvez voir que j'ai déjà ajouté tous mes index de requête dans le cache. Donc, puisque je les ai ajoutés, je n’ai pas besoin de les définir dynamiquement.

Maintenant que nos index de requêtes sont prêts, j'ai ici ce morceau de code qui charge tous mes produits dans le cache à partir de la base de données. Donc, je vais juste aller de l'avant et décommenter ce morceau de code. Parfait!

// ------------------------Load ALL Products Into Cache------------------------
...
	var products_caching_option = new CachingOptions
	{
	   StoreAs = StoreAs.SeparateEntities
	};

	products_caching_option.SetAbsoluteExpiration(DateTime.Now.AddDays(10));

	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}"));
	});
...

Et tout ce que ce code fait, c'est définir que je souhaite placer mes produits dans des entités distinctes et que je souhaite les ajouter avec une expiration de 10 jours. Ensuite ceci LoadIntoCache() La méthode charge les produits dans le cache. Maintenant, exécutons ceci et examinons les résultats obtenus. Parfait! Alors maintenant, si nous faisons défiler vers le haut, c'est parti ! On voit que nous avons chargé tous les produits dans le cache, ces 77 produits.

Et puis, si on peut voir ces requêtes qui sont arrivées dans le cache, ces ajouts qui ont été effectués, et ce décompte qui a considérablement augmenté. Si nous ouvrons nos statistiques, nous pouvons voir que nous avons 59 éléments sur une partition et 41 sur l'autre.

Maintenant, exportons les clés de cache et examinons les données dont nous disposons. Parfait! Nous avons donc 100 clés dans notre cache et tous les produits ont été introduits dans le cache. Parfait! Alors maintenant que l’intégralité de notre ensemble de données est disponible, je n’ai plus besoin de réexécuter cette méthode. Je vais juste aller de l'avant et commenter ceci.

Et maintenant, nous allons exécuter le FromCacheOnly() méthode d'extension sur notre requête de produits que nous avons déjà exécutée. Alors, j'ajoute simplement '. FromCacheOnly(). Parfait! Et maintenant, allons-y, exécutons l'échantillon et examinons les résultats de cette récupération pour nous. Parfait! Donc voilà, 26 résultats, les mêmes que ceux que nous avons obtenus lorsque nous avons exécuté cette application sans aucune mise en cache, ce qui signifie un résultat complet, et nous pouvons voir les récupérations qui ont été effectuées et les requêtes que nous avons reçues sur le cache.

Spécifique au noyau EF NCache Apis

Et cela résume assez bien la façon dont vous pouvez utiliser le FromCacheOnly() les LoadIntoCache() méthode d'extension. Et cela nous amène au problème spécifique à EF Core. NCache API que vous pouvez utiliser. Ainsi, disons, par exemple, que vous ne vouliez pas utiliser les méthodes d'extension et que vous souhaitiez travailler avec des entités indépendantes dans lesquelles vous créez une entité, la conservez dans le contexte, puis la placez dans le cache. Bien, NCache vous permet de le faire avec le Spécifique à EF Core NCache Apis. Ainsi, la façon dont cela fonctionne est que vous récupérez le contexte de cache à partir du contexte EF Core au sein de votre application. Et puis, une fois que vous disposez de ce contexte de cache, vous pouvez utiliser ce contexte de cache pour insérer des entités dans le cache ou pour supprimer des entités du cache.

Maintenant, il ne faut pas confondre cela avec les API fournies dans le NCache SDK. Ceux-ci sont spécifiques à Entity Framework Core et se comportent comme ils sont censés le faire avec Entity Framework Core. Ainsi, dans les données d'insertion, vous pouvez voir que nous allons insérer un client avec une clé de cache de chaîne externe. Et il s'agit d'une clé de cache fournie par l'API Entity Framework Core.

Maintenant, regardons comment cela fonctionne, et nous pourrons ensuite voir comment les éléments ou entités sont persistants dans le cache. Ainsi, si nous faisons défiler vers le bas, nous pouvons voir que je peux ajouter un client au cache à l'aide du handle de cache. Je vais donc simplement décommenter ce morceau de code ici. Parfait!

//-------------------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
	};

	options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));

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

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

Maintenant, si vous voyez que j'obtiens simplement le contexte du cache, je crée ce client ici. Je dis que je veux le stocker en tant qu'entité distincte avec une expiration de 10 minutes, ici. Je persiste simplement cela dans mon contexte, en enregistrant les modifications, puis en effectuant cette insertion de cache ici. Et puis, en imprimant que j'ai ajouté ce client dans le cache.

Alors maintenant, allons-y, exécutons le code et voyons comment cela fonctionne. Parfait! Ainsi, nous pouvons voir que le client a été ajouté dans le cache. Je vais juste fermer ceci. Nous pouvons voir cet ajout pour 1 qui a été effectué et cette augmentation dans notre décompte. Passons donc aux statistiques. Et voilà ! Donc, nous pouvons en voir 41, et le décompte est passé de 59 à 60.

Maintenant, allons-y et exportons les clés de cache. Parfait! Alors voilà ! Nous pouvons voir le client qui a été ajouté au cache et vous pouvez voir que l'API a attribué la clé de cache à cet élément. Nous n'avons pas eu besoin de spécifier une clé pour l'ajouter. Donc c'est parfait !

Maintenant, allons-y, permettez-moi de clarifier cela et supprimons ce client que nous avons mis dans le cache. Alors maintenant, je vais juste commenter ce morceau de code une fois de plus. Je vais juste commenter cela, et faisons défiler vers le bas et supprimons le client à l'aide du handle de cache. Donc, j'ai ce code ici. Donc, je vais juste tout sélectionner, et je vais juste le décommenter ici.

//-------------------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($"\n\nCustomer ID: {customerToRemove.Customerid} -> Removed from Cache");
	}
	else
	{
		Console.WriteLine("\n\ncould not find the customer within the cache");
	}

Et ce que fait ce code, c'est qu'il récupère à nouveau le cache du contexte et qu'il trouve ce client dans le contexte. Et si ce client est réellement trouvé, alors il va le supprimer du contexte, enregistrer les modifications, puis exécuter ce cache.Remove() pour supprimer le client, puis il affichera qu'il est fait. Sinon, s'il ne le trouve pas, il nous dira simplement qu'il n'a pas pu trouver le client dans le cache.

Maintenant, allons-y, sauvegardons ceci, exécutons cette application et regardons ce qui se passe. Parfait! J'ai donc trouvé le client et l'ai supprimé du cache. Génial!

Maintenant, terminons cela et examinons le décompte, et nous constatons qu'il est passé de 60 à 59. Les statistiques montrent également que le décompte est passé de 60 à 59. Maintenant, exportons les clés de cache. Nous devrions voir 100 clés maintenant. Parfait! Nous ne pouvons donc pas voir que le client que nous avons ajouté précédemment dans le décompte est revenu à 100. Et cela nous amène à peu près à la fin de cette démonstration. Merci beaucoup d'avoir regardé.

Prochaines étapes

Télécharger NCache

Maintenant, dans le cadre des prochaines étapes, ce que vous pouvez faire est, si vous souhaitez télécharger NCache, vous pouvez alors bénéficier d'un essai gratuit de 30 jours, qui vous offrira un produit entièrement fonctionnel. Vous pouvez le faire en vous rendant sur alachisoft.com ici, puis en allant sur le download à partir d'ici, et vous avez ici les offres que vous pouvez télécharger en fonction de vos besoins dans votre version .NET.

Essayez le terrain de jeu

Vous pouvez essaie le NCache cour de récréation pendant 30 minutes. Cela vous donne une sorte de session sandbox complète où vous pouvez jouer avec le code et voir comment les exemples fonctionneraient et avoir une idée du produit en général.

Planifiez un rendez-vous personnalisé NCache Démo

Enfin, vous pouvez également planifier un rendez-vous personnalisé NCache demo où nous vous fournirons un vidage d'une heure du NCache Caractéristiques et à quel point cela fonctionne. Nous pouvons également mapper le type de cas d'utilisation à vos problèmes et voir dans quelle mesure la mise en cache fonctionnerait bien dans votre environnement. Donc, vous pouvez simplement remplir ce formulaire ici et soumettez la demande. Vous pouvez être sûr que nous l'obtiendrons et que nous planifierons cette démo en conséquence.

Et cela nous amène à peu près à la fin de cette démo. Merci beaucoup d'avoir regardé. Bonne journée. Au revoir.