NCache si integra apparentemente con l'ASP.NET Core struttura. Con NCache, possiamo memorizzare nella cache i dati dell'applicazione o le risposte nel nostro ASP.NET Core applicazioni. Diamo un'occhiata a un altro NCache funzione per ASP.NET Core applicazioni: caching dello stato della sessione con ASP.NET Core.
HTTP e stato della sessione
Prima un po' di retroscena. HTTP è un protocollo senza stato. Significa che le richieste sono indipendenti l'una dall'altra e i server non conservano i dati degli utenti dalle richieste precedenti. Tuttavia, se dobbiamo archiviare i dati degli utenti mentre i nostri utenti navigano attraverso le nostre applicazioni Web, dobbiamo in qualche modo mantenere i valori degli utenti tra le richieste.
ASP.NET Core la documentazione ufficiale descrive diversi approcci per gestione dello stato. Come cookie, campi nascosti e stringhe di query, tra gli altri.
Per rendere persistenti i dati utente tra le richieste, ASP.NET Core si basa su un cookie e un meccanismo di archiviazione lato server. Ad ogni richiesta, ASP.NET Core passa un cookie con un identificatore per recuperare i dati della sessione sul lato server. Per impostazione predefinita, ASP.NET Core utilizza l'archiviazione in memoria per i dati della sessione.
Ma l'utilizzo dell'archiviazione in memoria per i dati della sessione presenta alcuni svantaggi. Nel caso in cui il nostro server delle applicazioni vada offline, perdiamo i dati della nostra sessione. Se reindirizzamo il nostro traffico, non otteniamo i dati della sessione replicati nella nuova posizione. Inoltre, se disponiamo di una server farm, dobbiamo collegare le sessioni a istanze specifiche dell'applicazione, rendendo difficile la scalabilità della nostra applicazione.
NCache per la cache dello stato della sessione HTTP
Possiamo usare NCache per la memorizzazione nella cache dello stato della sessione.
Con NCache, memorizziamo i dati della nostra sessione su un processo diverso, in un cluster, per essere precisi. In questo modo, non siamo limitati dalla quantità di memoria sul nostro server delle applicazioni. E possiamo ridimensionare il nostro cluster di cache aggiungendovi più server, aumentando la nostra capacità di transazione e archiviazione.
Grazie al NCache topologie di memorizzazione nella cache e la replica della sessione, se il nostro server delle applicazioni va offline, abbiamo ancora i nostri dati di sessione disponibili su tutti i nodi del server.
Con NCache, possiamo replicare i dati della nostra sessione in altre regioni o data center. Ad esempio, abbiamo sempre a disposizione i dati della sessione in caso di ripristino di emergenza. Anche noi possiamo conservare i dati della sessione nel luogo in cui sono stati creati e spostare i dati della sessione solo quando spostiamo il traffico tra le regioni, mantenendo bassi i costi di consumo della larghezza di banda.
Per ulteriori vantaggi dell'utilizzo NCache per lo stato della sessione, controlla ASP.NET Core Vantaggi e panoramica della memorizzazione nella cache.
Abbiamo solo bisogno di alcune modifiche al codice da utilizzare NCache per la memorizzazione nella cache dello stato della sessione. Abbiamo due approcci: uso NCache come fornitore di sessione o IDistributedCache
Provider.
Prima di utilizzare NCache come fornitore di sessioni, abbiamo bisogno del file AspNetCore.Session.NCache
pacchetto NuGet e aggiungere il file Alachisoft.NCache.Web.SessionState
spazio dei nomi.
Aggiungiamo NCache come provider di sessione per un ASP .NET 6.0 di esempio.NET Core applicazione web. Come questo,
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(); |
Innanzitutto, aggiungiamo NCache servizi per il caching dello stato della sessione all'ASP.NET Core contenitore delle dipendenze. Per questo, usiamo il AddNCacheSession()
metodo. Si aspetta un NCacheSessionConfiguration
oggetto. Dobbiamo passare come parametro obbligatorio un nome di cache. Opzionalmente possiamo abilitare i log (EnableLogs = true
) e passa un identificatore dell'applicazione per rendere univoco l'ID di sessione tra le applicazioni utilizzando gli stessi dati di sessione (SessionAppId = "demoApp"
).
Invece di configurare manualmente questi parametri, possiamo usare il file appsettings.json
file e passare una sezione di configurazione al file AddNCacheSession()
metodo.
Questa è la appsettings.json
file per le impostazioni del nostro esempio precedente,
1 2 3 4 5 6 7 8 |
{ "NCacheSettings": { "CacheName": "demoClusteredCache", "EnableLogs": "true", "SessionAppId": "demoApp" }, // Other settings here... } |
Per maggiori dettagli sulle impostazioni NCache ha per il suo provider di sessione, controlla ASP.NET Core Configurazione del provider di sessione.
Una volta registrati NCache services, dobbiamo configurare la pipeline delle richieste HTTP. Dobbiamo aggiungere il UseNCacheSession()
metodo. Teniamo d'occhio l'ordine del nostro middleware nella pipeline delle richieste. Dovremmo aggiungere il NCache middleware di sessione prima di qualsiasi altro middleware che legge i dati di sessione.
Inoltre, dopo aver aggiunto NCache servizi e middleware, accediamo ai nostri dati di sessione utilizzando il Http.Session
class all'interno delle pagine Razor e dei controller MVC.
2. NCache Implementazione di IDistributedCache per le sessioni
Invece di usare il AddNCacheSession()
ed UseNCacheSession()
metodi registrare NCache come provider di sessione, possiamo utilizzare ASP.NET Core sessioni con NCache Implementazione di IDistributedCache.
Per impostazione predefinita, ASP.NET Core ha la AddDistributedMemoryCache()
metodo per registrare un'implementazione in memoria di IDistributedCache
.
Invece di utilizzare tale implementazione, aggiungiamo il file NCache implementazione utilizzando il AddNCacheDistributedCache()
metodo.
Questa volta, installiamo il NCache.Microsoft.Extensions.Caching
pacchetto NuGet e usa il Alachisoft.NCache.Caching.Distributed
spazio dei nomi. Modifichiamo la precedente applicazione Web di esempio in use NCache IDistributedCache
implementazione,
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(); |
Avviso, invece di registrare il file NCache servizi e middleware per la memorizzazione nella cache dello stato della sessione, utilizziamo ASP.NET Core AddSession()
ed UseSession()
metodi. Tuttavia, specifichiamo una diversa implementazione della cache distribuita. Quello da NCache.
Per utilizzare l' AddNCacheDistributedCache()
metodo, dobbiamo passare il nome della cache come parametro obbligatorio. Di nuovo, possiamo usare il appsetttings.json
file invece. Facoltativamente, possiamo abilitare registri ed eccezioni e modificare il timeout della richiesta e riprovare. Per tutte le opzioni di configurazione disponibili per IDistributedCache
implementazione, controllo Configura ASP.NET Core IDistributedCache.
Dopo questi passaggi, possiamo accedere ai nostri dati di sessione utilizzando il file Http.Session
.
Conclusione
È così che possiamo ridimensionare il nostro ASP.NET Core applicazioni che utilizzano la cache dello stato della sessione con NCache. Di conseguenza, con solo poche modifiche al codice e configurazioni nelle nostre applicazioni.
NCache ha più funzioni per la gestione dello stato. Per esempio, NCache funziona come un file ASP multiregione.NET Core Fornitore di sessioni. Inoltre, in caso di ripristino di emergenza o reindirizzamento del traffico, possiamo replicare i dati della nostra sessione per evitare di perderli.
Inoltre, per quelle applicazioni con codebase legacy che utilizzano ancora ASP.NET Framework accanto alla nuova ASP.NET Core, Possiamo configure NCache per condividere le sessioni tra i due framework.
Quindi, dai un'occhiata più da vicino NCache per il caching della sessione controllando NCache Repository ufficiale GitHub per un'applicazione di esempio che utilizza la memorizzazione nella cache della sessione per creare un gioco di indovinelli.