NCache s'intègre apparemment avec l'ASP.NET Core cadre. Avec NCache, nous pouvons mettre en cache les données d'application ou les réponses dans notre ASP.NET Core applications. Jetons un coup d'oeil à un autre NCache fonctionnalité pour ASP.NET Core applications : mise en cache de l'état de la session avec ASP.NET Core.
HTTP et état de session
Un peu de contexte d'abord. HTTP est un protocole sans état. Cela signifie que les requêtes sont indépendantes les unes des autres et que les serveurs ne conservent pas les données utilisateur des requêtes précédentes. Mais, si nous devons stocker des données utilisateur pendant que nos utilisateurs naviguent dans nos applications Web, nous devons en quelque sorte conserver les valeurs utilisateur entre les demandes.
ASP.NET Core la documentation officielle décrit plusieurs approches pour gestion de l'état. Comme les cookies, les champs cachés et les chaînes de requête, entre autres.
Pour conserver les données utilisateur entre les requêtes, ASP.NET Core repose sur un cookie et un mécanisme de stockage côté serveur. A chaque demande, ASP.NET Core passe un cookie avec un identifiant pour récupérer les données de session côté serveur. Par défaut, ASP.NET Core utilise le stockage en mémoire pour les données de session.
Mais l'utilisation du stockage en mémoire pour les données de session présente certains inconvénients. Si notre serveur d'application se déconnecte, nous perdons nos données de session. Si nous redirigeons notre trafic, nous n'obtenons pas la réplication des données de session dans le nouvel emplacement. Et, si nous avons une batterie de serveurs, nous devons lier les sessions à des instances d'application spécifiques, ce qui rend notre application difficile à faire évoluer.
NCache pour la mise en cache de l'état de la session HTTP
Nous pouvons utiliser NCache pour la mise en cache de l'état de la session.
Avec NCache, nous stockons nos données de session sur un processus différent, dans un cluster, pour être précis. De cette façon, nous ne sommes pas limités par la quantité de mémoire sur notre serveur d'applications. Et nous pouvons faire évoluer notre cluster de cache en y ajoutant plus de serveurs, augmentant ainsi notre capacité de transaction et de stockage.
Grâce au NCache topologies de mise en cache et la réplication de session, si notre serveur d'applications se déconnecte, nos données de session sont toujours disponibles sur tous les nœuds du serveur.
Avec NCache, nous pouvons répliquer nos données de session dans d'autres régions ou centres de données. Nous avons toujours des données de session disponibles en cas de reprise après sinistre, par exemple. Même nous pouvons conserver les données de session à l'emplacement de leur création et déplacer les données de session uniquement lorsque nous déplaçons le trafic entre les régions, ce qui réduit les coûts de consommation de bande passante.
Pour plus d'avantages à utiliser NCache pour l'état de la session, vérifiez ASP.NET Core Avantages de la mise en cache et présentation.
Nous n'avons besoin que de quelques changements de code pour utiliser NCache pour la mise en cache de l'état de la session. Nous avons deux approches : utiliser NCache en tant que fournisseur de session ou IDistributedCache
Fournisseur.
Avant d'utiliser NCache en tant que fournisseur de sessions, nous avons besoin du AspNetCore.Session.NCache
package NuGet et ajoutez le Alachisoft.NCache.Web.SessionState
espace de noms.
Ajoutons NCache en tant que fournisseur de session pour un exemple d'ASP .NET 6.0.NET Core application Web. Comme ça,
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 30 31 32 33 34 35 36 37 38 |
using Alachisoft.NCache.Web.SessionState; var builder = WebApplication.CreateBuilder(args); builder.Services.AddRazorPages(); builder.Services.AddControllersWithViews(); // 1. Add NCache as a Session Provider builder.Services.AddNCacheSession(config => { config.CacheName = "demoClusteredCache"; // To log all error information. (Optional) config.EnableLogs = true; // An identifier to make SessionId unique between applications. (Optional) config.SessionAppId = "demoApp"; }); // Alternatively, read settings from the appsettings.json file // //var ncacheSettingsSection = builder.Configuration.GetSection("NCacheSettings"); //builder.Services.AddNCacheSession(ncacheSettingsSection); var app = builder.Build(); if (!app.Environment.IsDevelopment()) { app.UseExceptionHandler("/Error"); } app.UseStaticFiles(); app.UseRouting(); app.UseAuthorization(); // 2. Store NCache session data app.UseNCacheSession(); app.MapRazorPages(); app.MapDefaultControllerRoute(); app.Run(); |
Tout d'abord, nous ajoutons NCache services pour la mise en cache de l'état de session vers l'ASP.NET Core conteneur de dépendances. Pour cela, nous utilisons le AddNCacheSession()
méthode. Il attend une NCacheSessionConfiguration
objet. Nous devons passer en paramètre obligatoire un nom de cache. En option, nous pouvons activer les journaux (EnableLogs = true
) et transmettez un identifiant d'application pour rendre l'identifiant de session unique entre les applications utilisant les mêmes données de session (SessionAppId = "demoApp"
).
Au lieu de configurer manuellement ces paramètres, nous pouvons utiliser le appsettings.json
fichier et passez une section de configuration au AddNCacheSession()
méthode.
Il s'agit de la appsettings.json
fichier pour les paramètres de notre exemple précédent,
1 2 3 4 5 6 7 8 |
{ "NCacheSettings": { "CacheName": "demoClusteredCache", "EnableLogs": "true", "SessionAppId": "demoApp" }, // Other settings here... } |
Pour plus de détails sur les paramètres NCache a pour son fournisseur de session, cochez ASP.NET Core Configuration du fournisseur de sessions.
Une fois que nous nous sommes inscrits NCache services, nous devons configurer le pipeline de requêtes HTTP. Nous devons ajouter le UseNCacheSession()
méthode. Gardons un œil sur l'ordre de notre middleware dans le pipeline de requêtes. Nous devrions ajouter le NCache middleware de session avant tout autre middleware qui lit les données de session.
De plus, après avoir ajouté NCache services et middleware, nous accédons à nos données de session en utilisant le Http.Session
classe dans les pages Razor et les contrôleurs MVC.
2. NCache Implémentation de IDistributedCache pour les sessions
Au lieu d'utiliser le AddNCacheSession()
ainsi que UseNCacheSession()
méthodes pour vous inscrire NCache en tant que fournisseur de session, nous pouvons utiliser ASP.NET Core séances avec NCache Implémentation de IDistributedCache.
Par défaut, ASP.NET Core a l' AddDistributedMemoryCache()
méthode pour enregistrer une implémentation en mémoire de la IDistributedCache
.
Au lieu d'utiliser cette implémentation, ajoutons le NCache mise en œuvre à l'aide de la AddNCacheDistributedCache()
méthode.
Cette fois, nous installons le NCache.Microsoft.Extensions.Caching
package NuGet et utilisez le Alachisoft.NCache.Caching.Distributed
espace de noms. Modifions notre exemple d'application Web précédent pour utiliser NCache IDistributedCache
la mise en oeuvre,
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 30 31 32 33 34 |
using Alachisoft.NCache.Caching.Distributed; var builder = WebApplication.CreateBuilder(args); builder.Services.AddRazorPages(); builder.Services.AddControllersWithViews(); // 1. Add NCache Distributed Cache implementation builder.Services.AddNCacheDistributedCache(config => { config.CacheName = "demoClusteredCache"; // To log all error information. (Optional) config.EnableLogs = true; }); // 2. Add ASP.NET Core Session services builder.Services.AddSession(); var app = builder.Build(); if (!app.Environment.IsDevelopment()) { app.UseExceptionHandler("/Error"); } app.UseStaticFiles(); app.UseRouting(); app.UseAuthorization(); // 3. Add ASP.NET Core Session middleware app.UseSession(); app.MapRazorPages(); app.MapDefaultControllerRoute(); app.Run(); |
Remarquez qu'au lieu d'enregistrer le NCache services et middleware pour la mise en cache de l'état de session, nous utilisons ASP.NET Core AddSession()
ainsi que UseSession()
méthodes. Mais, nous spécifions une implémentation différente du cache distribué. Celui de NCache.
Pour utiliser la AddNCacheDistributedCache()
méthode, nous devons passer le nom du cache en tant que paramètre obligatoire. Encore une fois, nous pouvons utiliser le appsetttings.json
fichier à la place. En option, nous pouvons activer les journaux et les exceptions et modifier le délai d'expiration des demandes et les tentatives de nouvelle tentative. Pour toutes les options de configuration disponibles pour IDistributedCache
mise en œuvre, vérifier Configurer ASP.NET Core IDistributedCache.
Après ces étapes, nous pouvons accéder à nos données de session en utilisant le Http.Session
.
Conclusion
C'est ainsi que nous pouvons faire évoluer notre ASP.NET Core applications utilisant la mise en cache de l'état de session avec NCache. Par conséquent, avec seulement quelques changements de code et configurations dans nos applications.
NCache a plus de fonctionnalités pour la gestion de l'état. Par exemple, NCache fonctionne comme un ASP multi-régions.NET Core Fournisseur de sessions. De plus, en cas de reprise après sinistre ou de réacheminement du trafic, nous pouvons répliquer nos données de session pour éviter de perdre nos données de session.
De plus, pour les applications avec des bases de code héritées utilisant toujours ASP.NET Framework aux côtés du nouvel ASP.NET Core, nous pouvons configurer NCache partager des sessions entre les deux frameworks.
Alors, regardez de plus près NCache pour la mise en cache de session en cochant NCache Dépôt officiel GitHub pour un exemple d'application utilisant la mise en cache de session pour créer un jeu de devinettes.