Verteiltes Zwischenspeichern in ASP.NET Core

Ein verteilter Cache ist ein Von mehreren App-Servern gemeinsam genutzter Cache. Der Cache wird in der Regel als externer Dienst für die App-Server verwaltet, die darauf zugreifen. Ein verteilter Cache kann die Leistung und Skalierbarkeit einer ASP.NET Core-App verbessern, insbesondere, wenn ein Clouddienst oder eine Serverfarm die App hosten.

Ein verteilter Cache hat mehrere Vorteile gegenüber anderen Zwischenspeicherungsszenarien, in denen zwischengespeicherte Daten auf einzelnen App-Servern gespeichert werden.

Wenn zwischengespeicherte Daten verteilt werden, gilt für sie Folgendes:

• Sie sind kohärent (konsistent) für Anforderungen an mehrere Server.
• Sie überleben Serverneustarts und App-Bereitstellungen.
• Es verwendet keinen lokalen Arbeitsspeicher.

Die Konfiguration des verteilten Cache ist implementierungsspezifisch. In diesem Artikel wird beschrieben, wie Sie verteilte SQL Server-, Redis- oder Postgres-Caches konfigurieren. Nicht Microsoft Implementierungen sind auch verfügbar, z. B. NCache (NCache für GitHub), Azure Cosmos DB und Postgres. Unabhängig davon, welche Implementierung ausgewählt ist, interagiert die App mithilfe der IDistributedCache Schnittstelle mit dem Cache.

Anzeigen oder Herunterladen von Beispielcode (Vorgehensweise zum Herunterladen)

Prerequisites

Fügen Sie einen Paketverweis für den verwendeten verteilten Cacheanbieter hinzu:

• Für einen verteilten Redis-Cache Microsoft.Extensions.Caching.StackExchangeRedis.
• Für SQL Server wird Microsoft.Extensions.Caching.SqlServer verwendet.
• Für Postgres, Microsoft.Extensions.Caching.Postgres.
• Für Azure Cosmos DB Microsoft.Extensions.Caching.Cosmos.
• Für den verteilten NCache-Cache NCache.Microsoft.Extensions.Caching.OpenSource.

Verwenden der IDistributedCache-Schnittstelle

Die IDistributedCache-Schnittstelle bietet die folgenden Methoden zum Bearbeiten von Elementen bei der Implementierung des verteilten Cache:

• Get, GetAsync: Akzeptiert einen Zeichenfolgenschlüssel und ruft ein zwischengespeichertes Element als byte[]-Array ab, wenn es im Cache gefunden wird.
• Set, SetAsync: Fügt dem Cache mithilfe eines Zeichenfolgenschlüssels ein Element (als byte[] Array) hinzu.
• Refresh, RefreshAsync: Erneuert ein Element im Cache basierend auf seinem Schlüssel und setzt die gleitende Ablauffrist (sofern vorhanden) zurück.
• Remove, RemoveAsync: Entfernt ein Cacheelement anhand seines Zeichenfolgenschlüssels.

Einrichten verteilter Zwischenspeicherdienste

Registrieren Sie eine Implementierung IDistributedCache in der datei Program.cs . Die folgenden framework-bereitgestellten Implementierungen werden in diesem Artikel beschrieben:

• Verteilter Redis-Cache
• Verteilter Speichercache
• Verteilter SQL Server-Cache
• Verteilter Postgres-Cache
• Verteilter NCache-Cache
• Verteilter Azure Cosmos DB-Cache

Verteilter Redis-Cache

Der verteilte Redis-Cache bietet die beste Leistung und wird für Produktions-Apps empfohlen. Redis ist ein Open Source In-Memory-Datenspeicher, der häufig als verteilter Cache verwendet wird. Sie können eine Azure Cache for Redis-Instanz für eine von Azure gehostete ASP.NET Core-App konfigurieren und eine Azure Cache for Redis-Instanz für die lokale Entwicklung verwenden. Weitere Informationen finden Sie unter "Überprüfen von Cacheempfehlungen".

Eine App konfiguriert die Cacheimplementierung mit einer RedisCache Instanz durch Aufrufen der AddStackExchangeRedisCache Methode. Verwenden Sie für Ausgabecaching die AddStackExchangeRedisOutputCache Methode.

1. Erstellen Sie eine Instanz von Azure Cache for Redis.

2. Kopieren Sie die primäre Verbindungszeichenfolge (StackExchange.Redis) in Configuration.

   • Für die lokale Entwicklung: Speichern Sie die Verbindungszeichenfolge mit dem Secret Manager.

   • Für Azure: Speichern Sie die Verbindungskette in einem sicheren Speicher wie dem Azure Key Vault.

Der folgende Code aktiviert Azure Cache for Redis:

builder.Services.AddStackExchangeRedisCache(options =>
 {
     options.Configuration = builder.Configuration.GetConnectionString("MyRedisConStr");
     options.InstanceName = "SampleInstance";
 });

Der vorangehende Code geht davon aus, dass die primäre Verbindungszeichenfolge (StackExchange.Redis) in der Konfiguration mit dem Schlüsselnamen MyRedisConStr gespeichert ist.

Weitere Informationen finden Sie unter Azure Managed Redis.

Eine Diskussion zu alternativen Ansätzen für einen lokalen Redis-Cache finden Sie unter GitHub /dotnet/aspnetcore Issue #19542.

Verteilter Speichercache

Der verteilte Speichercache (AddDistributedMemoryCache) ist eine vom Framework bereitgestellte Implementierung, die IDistributedCache Elemente im Arbeitsspeicher speichert. Der verteilte Speichercache ist jedoch kein tatsächlich verteilter Cache. Die App-Instanz speichert die zwischengespeicherten Elemente auf dem Server, auf dem die App ausgeführt wird.

Der verteilte Speichercache ist eine nützliche Implementierung für Entwicklungs- und Testszenarien. Es ist auch nützlich für einen einzelnen Server in einem Produktionsszenario, bei dem die Arbeitsspeichernutzung kein Problem ist. Durch implementieren des verteilten Speichercaches werden zwischengespeicherte Datenspeicher abstrahiert. Dies ermöglicht die Implementierung einer echten verteilten Zwischenspeicherungslösung in der Zukunft, wenn mehrere Knoten oder Fehlertoleranz erforderlich werden.

Die Beispiel-App verwendet den verteilten Speichercache, wenn die App in der Umgebung in der Developmentdatei Program.cs ausgeführt wird.

builder.Services.AddDistributedMemoryCache();

Verteilter SQL Server-Cache

Die Implementierung des verteilten SQL Server Caches (AddDistributedSqlServerCache) ermöglicht dem verteilten Cache die Verwendung einer SQL Server Datenbank als Sicherungsspeicher. Um eine zwischengespeicherte SQL Server.Elementtabelle in einer SQL Server-Instanz zu erstellen, können Sie das Tool sql-cache verwenden. Das Tool erstellt eine Tabelle mit dem von Ihnen angegebenen Namen und Schema.

Erstellen Sie eine Tabelle in SQL Server, indem Sie den Befehl sql-cache create ausführen. Geben Sie die SQL Server-Instanz (Data Source), die Datenbank (Initial Catalog), das Schema (z. B. dbo) und den Tabellennamen (z. B. TestCache) an:

dotnet sql-cache create "Data Source=(localdb)/MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache

Wenn das Tool erfolgreich ist, wird eine Nachricht protokolliert:

Table and index were created successfully.

Die vom sql-cache-Tool erstellte Tabelle weist das folgende Schema auf:

Die Beispiel-App implementiert die SqlServerCache Klasse in einer Nichtentwicklungsumgebung (Development) in der datei Program.cs :

builder.Services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = builder.Configuration.GetConnectionString(
        "DistCache_ConnectionString");
    options.SchemaName = "dbo";
    options.TableName = "TestCache";
});

Weitere Informationen finden Sie unter SQL-Datenbank auf Azure.

Verteilter Postgres-Cache

Azure Database for PostgreSQL kann als verteilter Cache-Sicherungsspeicher über die IDistributedCache Schnittstelle verwendet werden. Azure Database for PostgreSQL ist ein vollständig verwaltetes, AI-ready Database-as-a-Service (DBaaS)-Angebot, das auf dem Open-Source-PostgreSQL-Modul basiert. Das Design unterstützt unternehmenskritische Workloads mit vorhersehbarer Leistung, robuster Sicherheit, hoher Verfügbarkeit und nahtloser Skalierbarkeit.

Konfigurieren Sie nach der Installation des Pakets "Microsoft.Extensions.Caching.Postgres NuGet" den verteilten Cache wie folgt:

1. Registrieren Sie den Dienst.

   using Microsoft.Extensions.DependencyInjection;
   
   var builder = WebApplication.CreateBuilder(args);
   
   // Register the Postgres distributed cache.
   builder.Services.AddDistributedPostgresCache(options => {
      options.ConnectionString = builder.Configuration.GetConnectionString("PostgresCache");
      options.SchemaName = builder.Configuration.GetValue<string>("PostgresCache:SchemaName", "public");
      options.TableName = builder.Configuration.GetValue<string>("PostgresCache:TableName", "cache");
      options.CreateIfNotExists = builder.Configuration.GetValue<bool>("PostgresCache:CreateIfNotExists", true);
      options.UseWAL = builder.Configuration.GetValue<bool>("PostgresCache:UseWAL", false);
   
      // Optional: Configure expiration settings.
   
      var expirationInterval = builder.Configuration.GetValue<string>("PostgresCache:ExpiredItemsDeletionInterval");
      if (!string.IsNullOrEmpty(expirationInterval) && TimeSpan.TryParse(expirationInterval, out var interval)) {
          options.ExpiredItemsDeletionInterval = interval;
      }
   
      var slidingExpiration = builder.Configuration.GetValue<string>("PostgresCache:DefaultSlidingExpiration");
      if (!string.IsNullOrEmpty(slidingExpiration) && TimeSpan.TryParse(slidingExpiration, out var sliding)) {
          options.DefaultSlidingExpiration = sliding;
      }
   });
   
   var app = builder.Build();
   

2. Verwenden Sie den Cache.

   public class MyService {
       private readonly IDistributedCache _cache; 
   
       public MyService(IDistributedCache cache) {
           _cache = cache;
       }
   
       public async Task<string> GetDataAsync(string key) {
           var cachedData = await _cache.GetStringAsync(key);
   
           if (cachedData == null) {
   
               // Fetch the data from source.
               var data = await FetchDataFromSource();
   
               // Cache the data with options.
               var options = new DistributedCacheEntryOptions {
                  AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30),
                  SlidingExpiration = TimeSpan.FromMinutes(5)
               };
   
               await _cache.SetStringAsync(key, data, options);
               return data;
           }
   
           return cachedData;
       }
   }
   

Verteilter NCache-Cache

NCache ist ein im Arbeitsspeicher verteilter Open Source-Cache, der nativ in .NET entwickelt wurde. NCache funktioniert sowohl lokal als auch als verteilter Cachecluster für eine ASP.NET Core-App, die in Azure oder auf anderen Hostingplattformen ausgeführt wird.

Informationen zum Installieren und Konfigurieren von NCache auf Ihrem lokalen Computer finden Sie im Handbuch für erste Schritte.

So konfigurieren Sie NCache:

1. Installieren Sie das NCache SDK NuGet-Paket, das NCache Opensource für .NET Framework und .NET Core-Apps unterstützt.

2. Konfigurieren Sie den Cachecluster in der Clientkonfiguration (die Datei "client.ncconf ").

3. Fügen Sie der datei Program.cs den folgenden Code hinzu:

builder.Services.AddNCacheDistributedCache(configuration =>
{
    configuration.CacheName = "democache";
    configuration.EnableLogs = true;
    configuration.ExceptionsEnabled = true;
});

Verteilter Azure Cosmos DB-Cache

Azure Cosmos DB kann in ASP.NET Core als Sitzungszustandsanbieter mithilfe der schnittstelle IDistributedCache konfiguriert werden. Azure Cosmos DB ist eine vollständig verwaltete NoSQL- und relationale Datenbank für die moderne Anwendungsentwicklung, die hohe Verfügbarkeit, Skalierbarkeit und Zugriff auf Daten mit geringer Latenz für unternehmenskritische Anwendungen bietet.

Nach der Installation des Microsoft. Extensions.Caching.Cosmos NuGet-Paket konfigurieren einen Azure Cosmos DB verteilten Cache. Sie können einen vorhandenen Azure Cosmos DB-Client verwenden oder einen neuen erstellen, wie in den folgenden Abschnitten beschrieben.

Weitere Informationen finden Sie in der Microsoft Caching-Erweiterung mit Azure Cosmos DB, der GitHub Repository-README-Datei für das NuGet-Paket.

Wiederverwenden eines vorhandenen Clients

Die einfachste Möglichkeit zum Konfigurieren eines verteilten Caches besteht darin, einen vorhandenen Azure Cosmos DB-Client erneut zu verwenden. In diesem Fall wird die CosmosClient-Instanz nicht entsorgt, wenn der Anbieter entsorgt wird.

services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
    cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
    cacheOptions.CosmosClient = existingCosmosClient;
    cacheOptions.CreateIfNotExists = true;
});

Erstellen eines neuen Clients

Alternativ können Sie einen neuen Client instanziieren. In diesem Fall wird die CosmosClient Instanz freigegeben, wenn der Anbieter freigegeben wird.

services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
    cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
    cacheOptions.ClientBuilder = new CosmosClientBuilder(Configuration["CosmosConnectionString"]);
    cacheOptions.CreateIfNotExists = true;
});

Verwenden des verteilten Cache

Um die IDistributedCache-Schnittstelle zu verwenden, fordern Sie eine Instanz von IDistributedCache in der App an. Die Instanz wird durch Abhängigkeitsinjektion (DI) bereitgestellt.

Wenn die Beispiel-App gestartet wird, wird die IDistributedCache Instanz in die datei Program.cs eingefügt. Die aktuelle Zeit wird mithilfe der IHostApplicationLifetime Schnittstelle zwischengespeichert. (Weitere Informationen finden Sie unter .NET Generic Host: IHostApplicationLifetime.)

app.Lifetime.ApplicationStarted.Register(() =>
{
    var currentTimeUTC = DateTime.UtcNow.ToString();
    byte[] encodedCurrentTimeUTC = System.Text.Encoding.UTF8.GetBytes(currentTimeUTC);
    var options = new DistributedCacheEntryOptions()
        .SetSlidingExpiration(TimeSpan.FromSeconds(20));
    app.Services.GetService<IDistributedCache>()
                              .Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
});

Die Beispiel-App fügt die IDistributedCache Instanz in das IndexModel Objekt ein, das von der Indexseite verwendet werden soll.

Jedes Mal, wenn die Indexseite geladen wird, wird der Cache mithilfe der OnGetAsync Methode auf die zwischengespeicherte Zeit überprüft. Wenn die zwischengespeicherte Zeit nicht abgelaufen ist, wird die Uhrzeit angezeigt. Wenn 20 Sekunden seit dem letzten Zugriff auf die zwischengespeicherte Zeit verstrichen sind (das letzte Mal, wenn diese Seite geladen wurde), zeigt die Seite die Meldung " Zwischengespeicherte Zeit abgelaufen" an.

Aktualisieren Sie die zwischengespeicherte Zeit sofort auf die aktuelle Uhrzeit, indem Sie die Option " Zwischengespeicherte Zeit zurücksetzen " auswählen. Diese Aktion löst die OnPostResetCachedTime Handlermethode aus.

public class IndexModel : PageModel
{
    private readonly IDistributedCache _cache;

    public IndexModel(IDistributedCache cache)
    {
        _cache = cache;
    }

    public string? CachedTimeUTC { get; set; }
    public string? ASP_Environment { get; set; }

    public async Task OnGetAsync()
    {
        CachedTimeUTC = "Cached Time Expired";
        var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");

        if (encodedCachedTimeUTC != null)
        {
            CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
        }

        ASP_Environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
        if (String.IsNullOrEmpty(ASP_Environment))
        {
            ASP_Environment = "Null, so Production";
        }
    }

    public async Task<IActionResult> OnPostResetCachedTime()
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        await _cache.SetAsync("cachedTimeUTC", encodedCurrentTimeUTC, options);

        return RedirectToPage();
    }
}

Überprüfen von Cacheempfehlungen

Berücksichtigen Sie bei der Entscheidung, welche Implementierung der IDistributedCache Schnittstelle für Ihre App am besten geeignet ist:

• Vorhandene Infrastruktur
• Leistungsanforderungen
• Cost
• Teamerfahrung

Zwischenspeicherlösungen basieren in der Regel auf In-Memory-Speicher, um einen schnellen Abruf von zwischengespeicherten Daten zu ermöglichen. Der Arbeitsspeicher ist jedoch nur eine begrenzte Ressource und seine Erweiterung kostspielig. Speichern Sie nur häufig verwendete Daten in einem Cache.

Für die meisten Apps bietet ein Redis-Cache einen höheren Durchsatz und eine geringere Latenz als ein SQL Server-Cache. Es wird jedoch ein Benchmarking empfohlen, um die Leistungsmerkmale von Zwischenspeicherungsstrategien zu bestimmen.

Wenn SQL Server der verteilte Cachesicherungsspeicher ist und der Cache- und App-Datenspeicher/-abruf dieselbe Datenbank verwendet, kann die Leistung reduziert werden. Der empfohlene Ansatz besteht darin, eine dedizierte SQL Server Instanz für den verteilten Cachesicherungsspeicher zu verwenden.

Verwandte Inhalte

• Redis Cache in Azure
• SQL-Datenbank in Azure
• Azure-Datenbank für PostgreSQL
• ASP.NET Core IDistributedCache-Anbieter für NCache in Webfarmen (NCache in GitHub)
• Repository README-Datei für Microsoft.Extensions.Caching.Cosmos
• Erkennen von Änderungen mit Änderungstoken in ASP.NET Core
• Cache-Taghilfsprogramm im ASP.NET Core MVC
• Taghilfsprogramm für verteilten Cache in ASP.NET Core
• Hosten von ASP.NET Core in einer Webfarm

Ein verteilter Cache ist ein Cache, der von mehreren App-Servern gemeinsam genutzt wird und in der Regel als externer Dienst für die App-Server verwaltet wird, die darauf zugreifen. Ein verteilter Cache kann die Leistung und Skalierbarkeit einer ASP.NET Core-App verbessern, insbesondere wenn die App von einem Clouddienst oder einer Serverfarm gehostet wird.

Ein verteilter Cache hat mehrere Vorteile gegenüber anderen Zwischenspeicherungsszenarien, in denen zwischengespeicherte Daten auf einzelnen App-Servern gespeichert werden.

Wenn zwischengespeicherte Daten verteilt werden, gilt Folgendes:

• Sie sind kohärent (konsistent) für Anforderungen an mehrere Server.
• Übersteht Serverneustarts und App-Bereitstellungen.
• Verwendet keinen lokalen Arbeitsspeicher.

Die Konfiguration des verteilten Cache ist implementierungsspezifisch. In diesem Artikel wird beschrieben, wie Sie verteilte SQL Server-, Redis- und Postgres-Caches konfigurieren. Drittanbieterimplementierungen sind ebenfalls verfügbar, z. B. NCache (NCache auf GitHub). Unabhängig davon, welche Implementierung ausgewählt ist, interagiert die App über die Schnittstelle IDistributedCache mit dem Cache.

Anzeigen oder Herunterladen von Beispielcode (Vorgehensweise zum Herunterladen)

Prerequisites

Fügen Sie einen Paketverweis für den verwendeten verteilten Cacheanbieter hinzu:

• Für einen verteilten Redis-Cache Microsoft.Extensions.Caching.StackExchangeRedis.

• Für SQL Server Microsoft.Extensions.Caching.SqlServer.

• Für Postgres, Microsoft.Extensions.Caching.Postgres.

• Für den verteilten NCache-Cache NCache.Microsoft.Extensions.Caching.OpenSource.

• Warning

  In diesem Artikel wird eine lokale Datenbank verwendet, für die keine Authentifizierung des Benutzers erforderlich ist. Produktions-Apps sollten den sichersten verfügbaren Ablauf für die Authentifizierung verwenden. Weitere Informationen zur Authentifizierung für bereitgestellte Test- und Produktions-Apps finden Sie unter Sichere Authentifizierungsflows.

IDistributedCache-Schnittstelle

Die IDistributedCache-Schnittstelle bietet die folgenden Methoden zum Bearbeiten von Elementen bei der Implementierung des verteilten Cache:

• Get, GetAsync: Akzeptiert einen Zeichenfolgenschlüssel und ruft ein zwischengespeichertes Element als byte[]-Array ab, wenn es im Cache gefunden wird.
• Set, SetAsync: Fügt dem Cache mithilfe eines Zeichenfolgenschlüssels ein Element (als byte[]-Array) hinzu.
• Refresh, RefreshAsync: Aktualisiert ein Element im Cache auf Grundlage seines Schlüssels und setzt die gleitende Ablaufzeit (sofern vorhanden) zurück.
• Remove, RemoveAsync: Entfernt ein Cacheelement anhand seines Zeichenfolgenschlüssels.

Einrichten verteilter Zwischenspeicherdienste

Registrieren Sie eine Implementierung von IDistributedCache in Program.cs. Im Framework bereitgestellte Implementierungen, die in diesem Thema beschrieben werden, umfassen:

• Verteilter Redis-Cache
• Verteilter Speichercache
• Verteilter SQL Server-Cache
• Verteilter Postgres-Cache
• Verteilter NCache-Cache

Verteilter Redis-Cache

Es wird empfohlen, dass Produktions-Apps den verteilten Redis-Cache verwenden, da er am leistungsfähigsten ist. Weitere Informationen finden Sie unter Empfehlungen.

Redis ist ein Open Source In-Memory-Datenspeicher, der häufig als verteilter Cache verwendet wird. Sie können einen Azure Redis Cache für eine von Azure gehostete ASP.NET Core-App konfigurieren und einen Azure Redis Cache für die lokale Entwicklung verwenden.

Eine App konfiguriert die Cacheimplementierung mithilfe einer RedisCache-Instanz (AddStackExchangeRedisCache).

1. Erstellen Sie einen Azure Cache for Redis.
2. Kopieren Sie die primäre Verbindungszeichenfolge (StackExchange.Redis) in Configuration.
   • Lokale Entwicklung: Speichern Sie die Verbindungszeichenfolge mit Secret Manager.
   • Azure: Speichern der Verbindungszeichenfolge in einem sicheren Speicher wie Azure Key Vault

Der folgende Code aktiviert Azure Cache for Redis:

builder.Services.AddStackExchangeRedisCache(options =>
 {
     options.Configuration = builder.Configuration.GetConnectionString("MyRedisConStr");
     options.InstanceName = "SampleInstance";
 });

Im vorherigen Code wird davon ausgegangen, dass die primäre Verbindungszeichenfolge (StackExchange.Redis) in der Konfiguration mit dem Schlüsselnamen MyRedisConStr gespeichert wurde.

Weitere Informationen finden Sie unter Azure Cache for Redis.

In diesem GitHub-Problem finden Sie eine Diskussion zu alternativen Ansätzen für einen lokalen Redis-Cache.

Verteilter Speichercache

Der verteilte Speichercache (AddDistributedMemoryCache) ist eine vom Framework bereitgestellte Implementierung von IDistributedCache, die Elemente im Arbeitsspeicher speichert. Der verteilte Speichercache ist kein tatsächlich verteilter Cache. Zwischengespeicherte Elemente werden von der App-Instanz auf dem Server gespeichert, auf dem die App ausgeführt wird.

Der verteilte Speichercache ist eine nützliche Implementierung:

• In Entwicklungs- und Testszenarien.
• Wenn ein einzelner Server in der Produktion verwendet wird und die Arbeitsspeichernutzung kein Problem ist. Durch die Implementierung des verteilten Cache-Speichers wird die Zwischenspeicherung von Daten abstrahiert. Dies ermöglicht die Implementierung einer echten verteilten Zwischenspeicherungslösung in der Zukunft, wenn mehrere Knoten oder Fehlertoleranz erforderlich werden.

Die Beispiel-App verwendet den verteilten Speichercache, wenn die App in der Development Umgebung ausgeführt wird in Program.cs:

builder.Services.AddDistributedMemoryCache();

Verteilter SQL Server-Cache

Die Implementierung des verteilten SQL Server-Cache (AddDistributedSqlServerCache) ermöglicht es dem verteilten Cache, eine SQL Server-Datenbank als Sicherungsspeicher zu verwenden. Um eine zwischengespeicherte SQL Server.Elementtabelle in einer SQL Server-Instanz zu erstellen, können Sie das Tool sql-cache verwenden. Das Tool erstellt eine Tabelle mit dem von Ihnen angegebenen Namen und Schema.

Erstellen Sie eine Tabelle in SQL Server, indem Sie den Befehl sql-cache create ausführen. Geben Sie die SQL Server-Instanz (Data Source), die Datenbank (Initial Catalog), das Schema (z. B. dbo) und den Tabellennamen (z. B. TestCache) an:

dotnet sql-cache create "Data Source=(localdb)/MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache

Eine Meldung wird protokolliert, um anzugeben, dass das Tool erfolgreich war:

Table and index were created successfully.

Die vom sql-cache-Tool erstellte Tabelle weist das folgende Schema auf:

Die Beispiel App implementiert SqlServerCache in einer nicht-Development Umgebung in Program.cs:

builder.Services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = builder.Configuration.GetConnectionString(
        "DistCache_ConnectionString");
    options.SchemaName = "dbo";
    options.TableName = "TestCache";
});

Verteilter Postgres-Cache

Azure Database for PostgreSQL kann als verteilter Cache-Sicherungsspeicher über die IDistributedCache Schnittstelle verwendet werden. Azure Database for PostgreSQL ist ein vollständig verwaltetes, AI-ready Database-as-a-Service (DBaaS)-Angebot, das auf dem Open-Source-PostgreSQL-Modul basiert, das darauf ausgelegt ist, unternehmenskritische Workloads mit vorhersehbarer Leistung, robuster Sicherheit, hoher Verfügbarkeit und nahtloser Skalierbarkeit zu unterstützen.

Konfigurieren Sie nach der Installation des Pakets "Microsoft.Extensions.Caching.Postgres NuGet" den verteilten Cache wie folgt:

1. Registrieren des Diensts

using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Register Postgres distributed cache
builder.Services.AddDistributedPostgresCache(options => {
    options.ConnectionString = builder.Configuration.GetConnectionString("PostgresCache");
    options.SchemaName = builder.Configuration.GetValue<string>("PostgresCache:SchemaName", "public");
    options.TableName = builder.Configuration.GetValue<string>("PostgresCache:TableName", "cache");
    options.CreateIfNotExists = builder.Configuration.GetValue<bool>("PostgresCache:CreateIfNotExists", true);
    options.UseWAL = builder.Configuration.GetValue<bool>("PostgresCache:UseWAL", false);

    // Optional: Configure expiration settings

    var expirationInterval = builder.Configuration.GetValue<string>("PostgresCache:ExpiredItemsDeletionInterval");
    if (!string.IsNullOrEmpty(expirationInterval) && TimeSpan.TryParse(expirationInterval, out var interval)) {
        options.ExpiredItemsDeletionInterval = interval;
    }

    var slidingExpiration = builder.Configuration.GetValue<string>("PostgresCache:DefaultSlidingExpiration");
    if (!string.IsNullOrEmpty(slidingExpiration) && TimeSpan.TryParse(slidingExpiration, out var sliding)) {
        options.DefaultSlidingExpiration = sliding;
    }
});

var app = builder.Build();

2. Verwenden des Caches

public class MyService {
    private readonly IDistributedCache _cache; 

    public MyService(IDistributedCache cache) {
        _cache = cache;
    }

    public async Task<string> GetDataAsync(string key) {
        var cachedData = await _cache.GetStringAsync(key);

        if (cachedData == null) {
            // Fetch data from source
            var data = await FetchDataFromSource();

            // Cache the data with options
            var options = new DistributedCacheEntryOptions {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30),
                SlidingExpiration = TimeSpan.FromMinutes(5)
            };

            await _cache.SetStringAsync(key, data, options);
            return data;
        }

        return cachedData;
    }
}

Verteilter NCache-Cache

NCache ist ein verteilter Open Source In-Memory-Cache, der nativ in .NET und .NET Core entwickelt wurde. NCache funktioniert sowohl lokal als auch als verteilter Cachecluster für eine ASP.NET Core-App, die in Azure oder auf anderen Hostingplattformen ausgeführt wird.

Informationen zum Installieren und Konfigurieren von NCache auf Ihrem lokalen Computer finden Sie unter Leitfaden mit ersten Schritten für Windows (.NET und .NET Core).

So konfigurieren Sie NCache:

1. Installieren Sie NCache Open Source NuGet.
2. Konfigurieren Sie den Cachecluster in client.ncconf.
3. Fügen Sie den folgenden Code zu Program.cs hinzu:

builder.Services.AddNCacheDistributedCache(configuration =>
{
    configuration.CacheName = "democache";
    configuration.EnableLogs = true;
    configuration.ExceptionsEnabled = true;
});

Verwenden des verteilten Cache

Um die IDistributedCache-Schnittstelle zu verwenden, fordern Sie eine Instanz von IDistributedCache in der App an. Die Instanz wird durch Abhängigkeitsinjektion (DI) bereitgestellt.

Wenn die Beispiel-App gestartet wird, wird IDistributedCache in Program.cseingebracht. Die aktuelle Zeit wird mit IHostApplicationLifetime zwischengespeichert (weitere Informationen finden Sie unter Generischer Host: IHostApplicationLifetime):

app.Lifetime.ApplicationStarted.Register(() =>
{
    var currentTimeUTC = DateTime.UtcNow.ToString();
    byte[] encodedCurrentTimeUTC = System.Text.Encoding.UTF8.GetBytes(currentTimeUTC);
    var options = new DistributedCacheEntryOptions()
        .SetSlidingExpiration(TimeSpan.FromSeconds(20));
    app.Services.GetService<IDistributedCache>()
                              .Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
});

Die Beispiel-App bringt IDistributedCache zwecks Verwendung durch die Indexseite in IndexModel ein.

Jedes Mal, wenn die Indexseite geladen wird, wird der Cache auf die zwischengespeicherte Zeit in OnGetAsyncüberprüft. Wenn die zwischengespeicherte Zeit nicht abgelaufen ist, wird die Uhrzeit angezeigt. Wenn seit dem letzten Zugriff auf die zwischengespeicherte Zeit (das letzte Laden dieser Seite) 20 Sekunden verstrichen sind, wird auf der Seite Zwischengespeicherte Zeit abgelaufen angezeigt.

Aktualisieren Sie sofort die zwischengespeicherte Zeit auf die aktuelle Zeit, indem Sie die Schaltfläche Zwischengespeicherte Zeit zurücksetzen auswählen. Die Schaltfläche löst die Handlermethode OnPostResetCachedTime aus.

public class IndexModel : PageModel
{
    private readonly IDistributedCache _cache;

    public IndexModel(IDistributedCache cache)
    {
        _cache = cache;
    }

    public string? CachedTimeUTC { get; set; }
    public string? ASP_Environment { get; set; }

    public async Task OnGetAsync()
    {
        CachedTimeUTC = "Cached Time Expired";
        var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");

        if (encodedCachedTimeUTC != null)
        {
            CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
        }

        ASP_Environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
        if (String.IsNullOrEmpty(ASP_Environment))
        {
            ASP_Environment = "Null, so Production";
        }
    }

    public async Task<IActionResult> OnPostResetCachedTime()
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        await _cache.SetAsync("cachedTimeUTC", encodedCurrentTimeUTC, options);

        return RedirectToPage();
    }
}

Es ist nicht erforderlich, eine Singleton- oder bereichsbezogene Lebensdauer für IDistributedCache-Instanzen mit den integrierten Implementierungen zu verwenden.

Sie können zudem eine IDistributedCache-Instanz überall dort erstellen, wo Sie anstelle von DI eine Instanz benötigen, aber das Erstellen einer Instanz im Code kann das Testen Ihres Codes erschweren und gegen das Prinzip der expliziten Abhängigkeiten verstoßen.

Recommendations

Bei der Entscheidung, welche Implementierung von IDistributedCache für Ihre App am besten geeignet ist, sollten Sie Folgendes berücksichtigen:

• Vorhandene Infrastruktur
• Leistungsanforderungen
• Cost
• Teamerfahrung

Zwischenspeicherlösungen basieren in der Regel auf In-Memory-Speicher, um einen schnellen Abruf von zwischengespeicherten Daten zu ermöglichen. Der Arbeitsspeicher ist jedoch nur eine begrenzte Ressource und seine Erweiterung kostspielig. Speichern Sie nur häufig verwendete Daten in einem Cache.

Für die meisten Apps bietet ein Redis-Cache einen höheren Durchsatz und eine geringere Latenz als ein SQL Server-Cache. Es wird jedoch ein Benchmarking empfohlen, um die Leistungsmerkmale von Zwischenspeicherungsstrategien zu bestimmen.

Wenn SQL Server als verteilter Cachesicherungsspeicher verwendet wird, kann sich die Verwendung derselben Datenbank für den Cache und die normale Datenspeicherung der App und das Abrufen negativ auf die Leistung beider auswirken. Es wird empfohlen, eine dedizierte SQL Server-Instanz für den verteilten Cachesicherungsspeicher zu verwenden.

Weitere Ressourcen

• Redis Cache in Azure
• SQL-Datenbank in Azure
• Azure-Datenbank für PostgreSQL
• ASP.NET Core IDistributedCache-Anbieter für NCache in Webfarmen (NCache in GitHub)
• In-Memory-Caching in ASP.NET Core
• Erkennen von Änderungen mit Änderungstoken in ASP.NET Core
• Zwischenspeichern von Antworten in ASP.NET Core
• Middleware für das Zwischenspeichern von Antworten in ASP.NET Core
• Cache-Taghilfsprogramm im ASP.NET Core MVC
• Taghilfsprogramm für verteilten Cache in ASP.NET Core
• Hosten von ASP.NET Core in einer Webfarm

Ein verteilter Cache ist ein Cache, der von mehreren App-Servern gemeinsam genutzt wird und in der Regel als externer Dienst für die App-Server verwaltet wird, die darauf zugreifen. Ein verteilter Cache kann die Leistung und Skalierbarkeit einer ASP.NET Core-App verbessern, insbesondere wenn die App von einem Clouddienst oder einer Serverfarm gehostet wird.

Ein verteilter Cache hat mehrere Vorteile gegenüber anderen Zwischenspeicherungsszenarien, in denen zwischengespeicherte Daten auf einzelnen App-Servern gespeichert werden.

Wenn zwischengespeicherte Daten verteilt werden, gilt für sie Folgendes:

• Sie sind kohärent (konsistent) für Anforderungen an mehrere Server.
• Sie überleben Serverneustarts und App-Bereitstellungen.
• Es verwendet keinen lokalen Arbeitsspeicher.

Die Konfiguration des verteilten Cache ist implementierungsspezifisch. In diesem Artikel wird beschrieben, wie Sie verteilte SQL Server-, Redis- und Postgres-Caches konfigurieren. Drittanbieterimplementierungen sind ebenfalls verfügbar, z. B. NCache (NCache auf GitHub). Unabhängig davon, welche Implementierung ausgewählt ist, interagiert die App über die Schnittstelle IDistributedCache mit dem Cache.

Anzeigen oder Herunterladen von Beispielcode (Vorgehensweise zum Herunterladen)

Prerequisites

Um einen verteilten SQL Server-Cache zu verwenden, fügen Sie dem Paket Microsoft.Extensions.Caching.SqlServer einen Paketverweis hinzu.

Um einen verteilten Redis-Cache zu verwenden, fügen Sie dem Paket Microsoft.Extensions.Caching.StackExchangeRedis einen Paketverweis hinzu.

Um einen verteilten Cache von Postgres zu verwenden, fügen Sie einen Paketverweis auf das Paket "Microsoft.Extensions.Caching.Postgres " hinzu.

Um den verteilten NCache-Cache zu verwenden, fügen Sie dem Paket NCache.Microsoft.Extensions.Caching.OpenSource einen Paketverweis hinzu.

IDistributedCache-Schnittstelle

Die IDistributedCache-Schnittstelle bietet die folgenden Methoden zum Bearbeiten von Elementen bei der Implementierung des verteilten Cache:

• Get, GetAsync: Akzeptiert einen Zeichenfolgenschlüssel und ruft ein zwischengespeichertes Element als byte[]-Array ab, wenn es im Cache gefunden wird.
• Set, SetAsync: Fügt dem Cache mithilfe eines Zeichenfolgenschlüssels ein Element (als byte[]-Array) hinzu.
• Refresh, RefreshAsync: Erneuert ein Element im Cache basierend auf seinem Schlüssel und setzt die gleitende Ablauffrist (sofern vorhanden) zurück.
• Remove, RemoveAsync: Entfernt ein Cacheelement anhand seines Zeichenfolgenschlüssels.

Einrichten verteilter Zwischenspeicherdienste

Registrieren Sie eine Implementierung von IDistributedCache in Startup.ConfigureServices. Im Framework bereitgestellte Implementierungen, die in diesem Thema beschrieben werden, umfassen:

• Verteilter Speichercache
• Verteilter SQL Server-Cache
• Verteilter Redis-Cache
• Verteilter Postgres-Cache
• Verteilter NCache-Cache

Verteilter Speichercache

Der verteilte Speichercache (AddDistributedMemoryCache) ist eine vom Framework bereitgestellte Implementierung von IDistributedCache, die Elemente im Arbeitsspeicher speichert. Der verteilte Speichercache ist kein tatsächlich verteilter Cache. Zwischengespeicherte Elemente werden von der App-Instanz auf dem Server gespeichert, auf dem die App ausgeführt wird.

Der verteilte Speichercache ist eine nützliche Implementierung:

• In Entwicklungs- und Testszenarien.
• Wenn ein einzelner Server in der Produktion verwendet wird und die Arbeitsspeichernutzung kein Problem ist. Durch die Implementierung des verteilten Speichercache wird die Speicherung von Cachedaten abstrahiert. Dies ermöglicht die Implementierung einer echten verteilten Zwischenspeicherungslösung in der Zukunft, wenn mehrere Knoten oder Fehlertoleranz erforderlich werden.

Die Beispiel-App verwendet den verteilten Speichercache, wenn die App in der Development Umgebung ausgeführt wird in Startup.ConfigureServices:

services.AddDistributedMemoryCache();

Verteilter SQL Server-Cache

Die Implementierung des verteilten SQL Server-Cache (AddDistributedSqlServerCache) ermöglicht es dem verteilten Cache, eine SQL Server-Datenbank als Sicherungsspeicher zu verwenden. Um eine zwischengespeicherte SQL Server.Elementtabelle in einer SQL Server-Instanz zu erstellen, können Sie das Tool sql-cache verwenden. Das Tool erstellt eine Tabelle mit dem von Ihnen angegebenen Namen und Schema.

Erstellen Sie eine Tabelle in SQL Server, indem Sie den Befehl sql-cache create ausführen. Geben Sie die SQL Server-Instanz (Data Source), die Datenbank (Initial Catalog), das Schema (z. B. dbo) und den Tabellennamen (z. B. TestCache) an:

dotnet sql-cache create "Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache

Eine Meldung wird protokolliert, um anzugeben, dass das Tool erfolgreich war:

Table and index were created successfully.

Die vom sql-cache-Tool erstellte Tabelle weist das folgende Schema auf:

Die Beispiel App implementiert SqlServerCache in einer nicht-Development Umgebung in Startup.ConfigureServices:

services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = 
        _config["DistCache_ConnectionString"];
    options.SchemaName = "dbo";
    options.TableName = "TestCache";
});

Verteilter Redis-Cache

Redis ist ein Open Source In-Memory-Datenspeicher, der häufig als verteilter Cache verwendet wird. Sie können einen Azure Redis Cache für eine von Azure gehostete ASP.NET Core-App konfigurieren und einen Azure Redis Cache für die lokale Entwicklung verwenden.

Eine App konfiguriert die Cacheimplementierung mithilfe einer RedisCache-Instanz (AddStackExchangeRedisCache).

1. Erstellen Sie einen Azure Cache for Redis.
2. Kopieren Sie die primäre Verbindungszeichenfolge (StackExchange.Redis) in Configuration.
   • Lokale Entwicklung: Speichern Sie die Verbindungszeichenfolge mit Secret Manager.
   • Azure: Speichern der Verbindungszeichenfolge in einem sicheren Speicher wie Azure Key Vault

Der folgende Code aktiviert Azure Cache for Redis:

public void ConfigureServices(IServiceCollection services)
{
    if (_hostContext.IsDevelopment())
    {
        services.AddDistributedMemoryCache();
    }
    else
    {
        services.AddStackExchangeRedisCache(options =>
        {
            options.Configuration = _config["MyRedisConStr"];
            options.InstanceName = "SampleInstance";
        });
    }

    services.AddRazorPages();
}

Im vorherigen Code wird davon ausgegangen, dass die primäre Verbindungszeichenfolge (StackExchange.Redis) in der Konfiguration mit dem Schlüsselnamen MyRedisConStr gespeichert wurde.

Weitere Informationen finden Sie unter Azure Cache for Redis.

In diesem GitHub-Problem finden Sie eine Diskussion zu alternativen Ansätzen für einen lokalen Redis-Cache.

Verteilter Postgres-Cache

Azure Database for PostgreSQL kann als verteilter Cache-Sicherungsspeicher über die IDistributedCache Schnittstelle verwendet werden. Azure Database for PostgreSQL ist ein vollständig verwaltetes, AI-ready Database-as-a-Service (DBaaS)-Angebot, das auf dem Open-Source-PostgreSQL-Modul basiert, das darauf ausgelegt ist, unternehmenskritische Workloads mit vorhersehbarer Leistung, robuster Sicherheit, hoher Verfügbarkeit und nahtloser Skalierbarkeit zu unterstützen.

Konfigurieren Sie nach der Installation des Pakets "Microsoft.Extensions.Caching.Postgres NuGet" den verteilten Cache wie folgt:

1. Registrieren des Diensts

using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Register Postgres distributed cache
builder.Services.AddDistributedPostgresCache(options => {
    options.ConnectionString = builder.Configuration.GetConnectionString("PostgresCache");
    options.SchemaName = builder.Configuration.GetValue<string>("PostgresCache:SchemaName", "public");
    options.TableName = builder.Configuration.GetValue<string>("PostgresCache:TableName", "cache");
    options.CreateIfNotExists = builder.Configuration.GetValue<bool>("PostgresCache:CreateIfNotExists", true);
    options.UseWAL = builder.Configuration.GetValue<bool>("PostgresCache:UseWAL", false);

    // Optional: Configure expiration settings

    var expirationInterval = builder.Configuration.GetValue<string>("PostgresCache:ExpiredItemsDeletionInterval");
    if (!string.IsNullOrEmpty(expirationInterval) && TimeSpan.TryParse(expirationInterval, out var interval)) {
        options.ExpiredItemsDeletionInterval = interval;
    }

    var slidingExpiration = builder.Configuration.GetValue<string>("PostgresCache:DefaultSlidingExpiration");
    if (!string.IsNullOrEmpty(slidingExpiration) && TimeSpan.TryParse(slidingExpiration, out var sliding)) {
        options.DefaultSlidingExpiration = sliding;
    }
});

var app = builder.Build();

2. Verwenden des Caches

public class MyService {
    private readonly IDistributedCache _cache; 

    public MyService(IDistributedCache cache) {
        _cache = cache;
    }

    public async Task<string> GetDataAsync(string key) {
        var cachedData = await _cache.GetStringAsync(key);

        if (cachedData == null) {
            // Fetch data from source
            var data = await FetchDataFromSource();

            // Cache the data with options
            var options = new DistributedCacheEntryOptions {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30),
                SlidingExpiration = TimeSpan.FromMinutes(5)
            };

            await _cache.SetStringAsync(key, data, options);
            return data;
        }

        return cachedData;
    }
}

Verteilter NCache-Cache

NCache ist ein verteilter Open Source In-Memory-Cache, der nativ in .NET und .NET Core entwickelt wurde. NCache funktioniert sowohl lokal als auch als verteilter Cachecluster für eine ASP.NET Core-App, die in Azure oder auf anderen Hostingplattformen ausgeführt wird.

Informationen zum Installieren und Konfigurieren von NCache auf Ihrem lokalen Computer finden Sie unter Leitfaden mit ersten Schritten für Windows (.NET und .NET Core).

So konfigurieren Sie NCache:

1. Installieren Sie NCache Open Source NuGet.

2. Konfigurieren Sie den Cachecluster in client.ncconf.

3. Fügen Sie den folgenden Code zu Startup.ConfigureServices hinzu:

   services.AddNCacheDistributedCache(configuration =>    
   {        
       configuration.CacheName = "demoClusteredCache";
       configuration.EnableLogs = true;
       configuration.ExceptionsEnabled = true;
   });
   

Verwenden des verteilten Cache

Um die IDistributedCache-Schnittstelle zu verwenden, fordern Sie eine Instanz von IDistributedCache von einem beliebigen Konstruktor in der App an. Die Instanz wird durch Abhängigkeitsinjektion (DI) bereitgestellt.

Wenn die Beispiel-App gestartet wird, wird IDistributedCache in Startup.Configureeingebracht. Die aktuelle Zeit wird mit IHostApplicationLifetime zwischengespeichert (weitere Informationen finden Sie unter Generischer Host: IHostApplicationLifetime):

public void Configure(IApplicationBuilder app, IWebHostEnvironment env, 
    IHostApplicationLifetime lifetime, IDistributedCache cache)
{
    lifetime.ApplicationStarted.Register(() =>
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        cache.Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
    });

Die Beispiel-App bringt IDistributedCache zwecks Verwendung durch die Indexseite in IndexModel ein.

Jedes Mal, wenn die Indexseite geladen wird, wird der Cache auf die zwischengespeicherte Zeit in OnGetAsyncüberprüft. Wenn die zwischengespeicherte Zeit nicht abgelaufen ist, wird die Uhrzeit angezeigt. Wenn seit dem letzten Zugriff auf die zwischengespeicherte Zeit (das letzte Laden dieser Seite) 20 Sekunden verstrichen sind, wird auf der Seite Zwischengespeicherte Zeit abgelaufen angezeigt.

Aktualisieren Sie sofort die zwischengespeicherte Zeit auf die aktuelle Zeit, indem Sie die Schaltfläche Zwischengespeicherte Zeit zurücksetzen auswählen. Die Schaltfläche löst die Handlermethode OnPostResetCachedTime aus.

public class IndexModel : PageModel
{
    private readonly IDistributedCache _cache;

    public IndexModel(IDistributedCache cache)
    {
        _cache = cache;
    }

    public string CachedTimeUTC { get; set; }

    public async Task OnGetAsync()
    {
        CachedTimeUTC = "Cached Time Expired";
        var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");

        if (encodedCachedTimeUTC != null)
        {
            CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
        }
    }

    public async Task<IActionResult> OnPostResetCachedTime()
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        await _cache.SetAsync("cachedTimeUTC", encodedCurrentTimeUTC, options);

        return RedirectToPage();
    }
}

Recommendations

Bei der Entscheidung, welche Implementierung von IDistributedCache für Ihre App am besten geeignet ist, sollten Sie Folgendes berücksichtigen:

• Vorhandene Infrastruktur
• Leistungsanforderungen
• Cost
• Teamerfahrung

Zwischenspeicherlösungen basieren in der Regel auf In-Memory-Speicher, um einen schnellen Abruf von zwischengespeicherten Daten zu ermöglichen. Der Arbeitsspeicher ist jedoch nur eine begrenzte Ressource und seine Erweiterung kostspielig. Speichern Sie nur häufig verwendete Daten in einem Cache.

Im Allgemeinen bietet ein Redis-Cache einen höheren Durchsatz und eine geringere Latenzzeit als ein SQL Server-Cache. Es ist jedoch in der Regel ein Benchmarking erforderlich, um die Leistungsmerkmale von Zwischenspeicherungsstrategien zu bestimmen.

Wenn SQL Server als verteilter Cachesicherungsspeicher verwendet wird, kann sich die Verwendung derselben Datenbank für den Cache und die normale Datenspeicherung der App und das Abrufen negativ auf die Leistung beider auswirken. Es wird empfohlen, eine dedizierte SQL Server-Instanz für den verteilten Cachesicherungsspeicher zu verwenden.

Weitere Ressourcen

• Redis Cache in Azure
• SQL-Datenbank in Azure
• Azure-Datenbank für PostgreSQL
• ASP.NET Core IDistributedCache-Anbieter für NCache in Webfarmen (NCache in GitHub)
• In-Memory-Caching in ASP.NET Core
• Erkennen von Änderungen mit Änderungstoken in ASP.NET Core
• Zwischenspeichern von Antworten in ASP.NET Core
• Middleware für das Zwischenspeichern von Antworten in ASP.NET Core
• Cache-Taghilfsprogramm im ASP.NET Core MVC
• Taghilfsprogramm für verteilten Cache in ASP.NET Core
• Hosten von ASP.NET Core in einer Webfarm