ASP.NET Core sta diventando popolare per lo sviluppo di applicazioni Web grazie alla sua architettura più pulita e leggera e al supporto multipiattaforma. Tale ASP.NET Core le applicazioni sono ad alto traffico e vengono eseguite in una distribuzione multi-server con bilanciamento del carico. In effetti, è comune vedere 10-20 web farm di server e alcune anche più grandi di questa.
Avere una distribuzione multi-server con bilanciamento del carico rende il tuo livello di applicazione molto scalabile perché puoi aggiungere più server man mano che aumenta il carico delle transazioni. Ciò consente al tuo ASP.NET Core applicazione per gestire facilmente carichi di transazioni pesanti. Esiste ancora un collo di bottiglia delle prestazioni che rallenta l'ASP.NET Core applicazione.
E questo ASP.NET Core il collo di bottiglia delle prestazioni è nel database e nell'archiviazione dei dati che non è in grado di gestire carichi pesanti come il tuo ASP.NET Core il livello di applicazione può. Sebbene sia possibile aggiungere più server alla Web farm a livello applicazione, non è possibile fare lo stesso con il livello database. Di seguito sono riportati i due tipi di archiviazione dei dati che diventano un collo di bottiglia delle prestazioni per ASP.NET Core applicazioni.
- Server di database (SQL Server)
- ASP.NET Core Sessioni
NCache Dettagli NCache Docs NCache API client
La soluzione: cache distribuita
Per rimuovere questi dati di archiviazione colli di bottiglia delle prestazioni, la soluzione migliore è utilizzare una cache distribuita come NCache. NCache è una cache distribuita in memoria open source .NET che è molto più veloce del database. A differenza del tuo database, NCache is linearmente scalabile perché ti consente di creare un cluster di server cache e aggiungere più server al cluster man mano che aumentano i carichi delle tue transazioni.
NCache consente di memorizzare nella cache i dati dell'applicazione in modo da poter ridurre di quasi l'80% i costosi spostamenti del database. Ciò riduce il carico sul database che gli consente di eseguire sia letture che scritture molto più velocemente e non diventare più un collo di bottiglia delle prestazioni.
NCache è anche un negozio distribuito scalabile per il tuo ASP.NET Core sessioni. Inoltre, NCache replica ASP.NET Core sessioni su più server per prevenire la perdita di dati nel caso in cui un server cache si interrompa. Per ASP.NET Core sessioni, questo è molto importante perché non puoi permetterti di perdere sessioni in fase di esecuzione. Di seguito è riportato un diagramma che mostra come piace una cache distribuita NCache si adatta alla distribuzione dell'applicazione.
NCache Dettagli NCache Docs NCache API client
Memorizzazione nella cache dei dati dell'app tramite ASP.NET Core IDistributedCache
Prima dell'ASP.NET Core, il vecchio ASP.NET forniva una versione autonoma Cache ASP.NET che non soddisfaceva le esigenze degli ambienti multi-server. Ora, ASP.NET Core ha introdotto il IDistributedCache interfaccia come un'API standard di memorizzazione nella cache distribuita abbastanza semplice che ti consente di programmare contro di essa e quindi collega senza problemi cache distribuite di terze parti.
Ecco un esempio di come usare IDistributedCache
interfaccia:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
IDistributedCache _cache; ... private byte[] LoadCustomer(string custId) { string key = "Customers:CustomerID:" + custId; // is the customer in the cache? byte[] customer = _cache.Get(key); if (customer == null) { // the cache doesn't have it. so load from DB customer = LoadFromDB(key); // And, cache it for next time _cache.Set(key, customer); } return customer; } |
NCache ha anche implementato un provider per IDistributedCache
che puoi collegare al tuo ASP.NET Core applicazioni. In questo modo, non è necessario modificare alcun codice specifico per NCache.
Ecco ciò che il IDistributedCache
l'interfaccia appare (si noti che ciascuno di questi metodi ha anche un sovraccarico Async).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
namespace Microsoft.Extensions.Caching.Distributed { public interface IDistributedCache { // Each of these methods also has an “Async” overload byte[] Get(string key); void Refresh(string key); void Remove(string key); // Specify absolute & sliding expiration through options void Set(string key, byte[] value, DistributedCacheEntryOptions options); } } |
Configurazione NCache come provider IDistributedCache
Ecco come si configura NCache come il tuo IDistributedCache
provider nel tuo ASP.NET Core Startup
classe.
1 2 3 4 5 6 7 8 9 10 11 |
public class Startup { ... public void ConfigureServices (IServiceCollection services) { ... services.AddNCacheDistributedCache(); ... } ... } |
NCache Dettagli ASP.NET Core Caching ASP.NET Core Fornitore di sessioni
Perché scegliere NCache API su IDistributedCache?
Se le tue esigenze di memorizzazione nella cache sono piuttosto basilari e desideri la flessibilità di cambiare senza problemi il fornitore di memorizzazione nella cache distribuita, allora dovresti andare avanti e utilizzare il IDistributedCache interfaccia. Ti consente di cambiare il tuo fornitore di cache senza problemi. Ma confrontalo con il costo di non avere molte funzionalità avanzate di memorizzazione nella cache.
Un'altra opzione è da usare NCache API direttamente dal tuo ASP.NET Core applicazione. NCache L'API è molto simile all'API ASP.NET Cache legacy. Contiene tonnellate di funzionalità gratuite che ti consentono di sfruttare appieno una cache distribuita di livello aziendale.
Ricorda, più dati puoi memorizzare nella cache, maggiori saranno i vantaggi in termini di prestazioni e scalabilità per la tua applicazione. E, senza le funzionalità avanzate di memorizzazione nella cache, sei spesso limitato alla memorizzazione nella cache di dati semplici o di sola lettura. Leggi di più su tutti i diversi NCache funzionalità di memorizzazione nella cache che ti manca usando il IDistributedCache
fornitore.
Memorizzazione di ASP.NET Core Sessioni nella cache distribuita
Prima dell'ASP.NET Core, il precedente ASP.NET forniva un framework ASP.NET Session State Provider che consentiva il plug-in di provider di archiviazione di sessione di terze parti. ASP.NET Core sessioni fornisce un meccanismo simile per collegare provider di archiviazione di terze parti. Di seguito sono riportati i due modi di utilizzo NCache come ASP.NET Core memorizzazione della sessione:
Usa il NCache per ASP.NET Core Sessioni tramite IDistributedCache
Non appena si configura NCache as IDistributedCache
fornitore per ASP.NET Core, NCache diventa automaticamente l'opzione di archiviazione predefinita per ASP.NET Core sessioni e non devi fare nient'altro. Ma tieni presente che questa implementazione è limitata nelle funzionalità rispetto alla precedente (prima di ASP.NET Core) Stato della sessione ASP.NET.
Ecco alcune delle cose che l'ASP predefinito.NET Core L'implementazione delle sessioni manca:
- Blocco della sessione: ASP.NET Core non fornisce il blocco della sessione. Questo è qualcosa che era stato fornito anche dallo stato della sessione ASP.NET più vecchio.
byte[]
array per oggetti personalizzati: ASP.NET Core ti costringe a convertire tutti i tuoi oggetti personalizzati in array di byte prima di poter archiviare è nella sessione. Anche lo stato della sessione ASP.NET precedente supporta oggetti personalizzati.
Usa il NCache come ASP.NET Core Fornitore di sessioni
Per aggirare l'ASP predefinito.NET Core Implementazione delle sessioni attraverso IDistributedCache
fornitore, NCache ha implementato il proprio ASP.NET Core Fornitore di sessioni. Questa implementazione ha molte più funzionalità rispetto a quella predefinita.
Ecco come lo configuri nel tuo Startup
classe.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class Startup { ... public void Configure(IApplicationBuilder app, IHostingEnvironment env) { ... app.UseNCacheSession(); ... } ... } |
È possibile specificare ASP.NET Core Configurazioni di sessione per quanto sopra in appsettings.json
file come segue:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
{ ... "NCacheSessions": { ... "CacheName": "demoCache", "EnableLogs": "True", "RequestTimeout": "90", "EnableDetailLogs": "False", "ExceptionsEnabled": "True", "WriteExceptionsToEventLog": "False" } ... } |
NCache Dettagli NCache Docs Configurazione NCache Provider IDistributedCache
Conclusione
Microsoft offre due opzioni come IDistributedCache
fornitori. Uno è SQL Server e il secondo è Redis. NCache è meglio di entrambe le opzioni. Rispetto a SQL Server, NCache è molto più veloce e scalabile. Anche, NCache è anche meglio di Redis per i seguenti motivi:
- .NET nativo: NCache è 100% nativo .NET e quindi si adatta molto bene allo stack di applicazioni .NET. D'altro canto, Redis proviene da uno sfondo Linux e non è una cache .NET nativa.
- Più veloce di Redis: NCache in realtà è più veloce di Redis as NCache La funzionalità Client Cache offre NCache un notevole incremento delle prestazioni.
- Altre caratteristiche: NCache offre una serie di importanti funzionalità di cache distribuita che Redis non. Vedi maggiori dettagli in questo Redis vs NCache.