Verteiltes Zwischenspeichern in ASP.NET Core

Von Mohsin Nasir und smandia

Ein verteilter Cache ist ein von mehreren App-Servern freigegebener Cache, der 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 Zwischenspeicherszenarien, in denen zwischengespeicherte Daten auf einzelnen App-Servern gespeichert werden.

Wenn zwischengespeicherte Daten verteilt werden, werden die Daten:

  • Ist konsistent (konsistent) über Anforderungen an mehrere Server hinweg.
  • Überlebt serverneustarts und App-Bereitstellungen.
  • Verwendet keinen lokalen Speicher.

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

Anzeigen oder Herunterladen von Beispielcode (Vorgehensweise zum Herunterladen)

Voraussetzungen

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

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

Fügen Sie zum Verwenden des verteilten NCache-Caches einen Paketverweis auf das Paket NCache.Microsoft.Extensions.Caching.OpenSource hinzu.

IDistributedCache-Schnittstelle

Die IDistributedCache Schnittstelle bietet die folgenden Methoden zum Bearbeiten von Elementen in der Implementierung des verteilten Caches:

  • Get, GetAsync: Akzeptiert einen Zeichenfolgenschlüssel und ruft ein zwischengespeichertes Element als Array ab byte[] , wenn er 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 basierend auf seinem Schlüssel, und setzt dessen Gleitzeitlimit (falls vorhanden) zurück.
  • Remove, RemoveAsync: Entfernt ein Cacheelement basierend auf seinem Zeichenfolgenschlüssel.

Einrichten von verteilten Cachediensten

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

Verteilter Speichercache

Der verteilte Speichercache (AddDistributedMemoryCache) ist eine framework-bereitgestellte Implementierung, die IDistributedCache 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 der Arbeitsspeicherverbrauch kein Problem ist. Die Implementierung des verteilten Speichercaches abstrahiert zwischengespeicherte Datenspeicher. Es ermöglicht die Implementierung einer echten verteilten Cachelösung in Zukunft, wenn mehrere Knoten oder Fehlertoleranz erforderlich werden.

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

builder.Services.AddDistributedMemoryCache();

Verteilter SQL Server-Cache

Die Implementierung des verteilten SQL Server-Caches (AddDistributedSqlServerCache) ermöglicht es dem verteilten Cache, eine SQL Server-Datenbank als Sicherungsspeicher zu verwenden. Zum Erstellen einer ZWISCHENgespeicherten SQL Server-Elementtabelle in einer SQL Server-Instanz können Sie das sql-cache Tool verwenden. Das Tool erstellt eine Tabelle mit dem namen und dem schema, den Sie angeben.

Erstellen Sie eine Tabelle in SQL Server, indem Sie den sql-cache create Befehl ausführen. Geben Sie die SQL Server-Instanz (), datenbank (Initial Catalog), das Schema (Data Sourcez. Bdbo. ) und den Tabellennamen an (zTestCache. B. ):

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

Eine Nachricht 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:

SqlServer Cache Table

Hinweis

Eine App sollte Cachewerte mithilfe einer Instanz von IDistributedCache, nicht einer SqlServerCache.

Die Beispiel-App implementiert SqlServerCache in einer Nicht-Entwicklungsumgebung in Program.cs:

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

Hinweis

Eine ConnectionString (und optional SchemaName ) TableNamewerden normalerweise außerhalb der Quellcodeverwaltung gespeichert (z. B. vom Geheimen Manager oder in appsettings.json/appsettings.{Environment}.json Dateien gespeichert). Die Verbindungszeichenfolge kann Anmeldeinformationen enthalten, die aus Quellcodeverwaltungssystemen herausgehalten werden sollten.

Verteilter Redis-Cache

Redis ist ein Open Source-Speicher im Arbeitsspeicher, 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 für Redis.
  2. Kopieren Sie die primäre Verbindungszeichenfolge (StackExchange.Redis) in die Konfiguration.
    • Lokale Entwicklung: Speichern Sie die Verbindungszeichenfolge mit dem geheimen Manager.
    • Azure: Speichern Sie die Verbindungszeichenfolge in der App-Dienstkonfiguration oder in einem anderen sicheren Speicher.

Der folgende Code aktiviert den Azure-Cache für 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 MyRedisConStrgespeichert 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 NCache-Cache

NCache ist ein open source-im Arbeitsspeicher verteilter Cache, der nativ in .NET und .NET Core entwickelt wurde. NCache funktioniert sowohl lokal als auch als verteilter Cachecluster für eine in Azure oder auf anderen Hostingplattformen ausgeführte ASP.NET Core-App.

Informationen zum Installieren und Konfigurieren von NCache auf Ihrem lokalen Computer finden Sie im Leitfaden für erste Schritte 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 Caches

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

Wenn die Beispiel-App gestartet wird, IDistributedCache wird sie injiziert Program.cs. Die aktuelle Zeit wird mithilfe IHostApplicationLifetime zwischengespeichert (weitere Informationen finden Sie unter 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 wird in die IndexModel Verwendung auf der Indexseite eingefügtIDistributedCache.

Jedes Mal, wenn die Indexseite geladen wird, wird der Cache für die zwischengespeicherte Zeit in OnGetAsyncaktiviert. Wenn die zwischengespeicherte Zeit nicht abgelaufen ist, wird die Uhrzeit angezeigt. Wenn 20 Sekunden seit dem letzten Zugriff auf die zwischengespeicherte Zeit abgelaufen sind (das letzte Mal, wenn diese Seite geladen wurde), zeigt die Seite " Zwischengespeicherte Zeit abgelaufen" an.

Aktualisieren Sie sofort die zwischengespeicherte Zeit auf die aktuelle Uhrzeit, indem Sie die Schaltfläche " Zwischengespeicherte Zeit zurücksetzen " auswählen. Die Schaltfläche 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();
    }
}

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

Sie können auch eine IDistributedCache Instanz erstellen, an der Sie eine Instanz anstelle von DI benötigen, aber das Erstellen einer Instanz im Code kann Ihren Code schwieriger testen und gegen das Explizite Abhängigkeitsprinzip verstoßen.

Empfehlungen

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

  • Vorhandene Infrastruktur
  • Leistungsanforderungen
  • Cost
  • Teamerfahrung

Zwischenspeicherlösungen basieren in der Regel auf speicherinternem Speicher, um schnelles Abrufen zwischengespeicherter Daten bereitzustellen, aber der Speicher ist eine begrenzte Ressource und kostspielig, um zu erweitern. Speichern Sie nur häufig verwendete Daten in einem Cache.

Im Allgemeinen bietet ein Redis-Cache einen höheren Durchsatz und eine geringere Latenz als ein SQL Server-Cache. Benchmarks sind jedoch in der Regel erforderlich, um die Leistungseigenschaften von Cachestrategien zu bestimmen.

Wenn SQL Server als verteilter Cache-Backing-Speicher verwendet wird, kann die Verwendung derselben Datenbank für den Cache und den normalen Datenspeicher der App negativ auf die Leistung der beiden auswirken. Es wird empfohlen, eine dedizierte SQL Server-Instanz für den verteilten Cache-Backing store zu verwenden.

Zusätzliche Ressourcen

Ein verteilter Cache ist ein Von mehreren App-Servern freigegebener Cache, der normalerweise 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 verfügt über mehrere Vorteile gegenüber anderen Zwischenspeicherszenarien, in denen zwischengespeicherte Daten auf einzelnen App-Servern gespeichert werden.

Wenn zwischengespeicherte Daten verteilt werden, werden die Daten:

  • Ist konsistent (konsistent) über Anforderungen an mehrere Server hinweg.
  • Überlebt serverneue Neustarts und App-Bereitstellungen.
  • Verwendet keinen lokalen Arbeitsspeicher.

Die verteilte Cachekonfiguration ist speziell für die Implementierung. In diesem Artikel wird beschrieben, wie Sie SQL Server und Redis verteilte Caches konfigurieren. Drittanbieterimplementierungen sind auch verfügbar, z. B. NCache (NCache auf GitHub). Unabhängig davon, welche Implementierung ausgewählt ist, interagiert die App mit dem Cache mithilfe der IDistributedCache Schnittstelle.

Anzeigen oder Herunterladen von Beispielcode (Vorgehensweise zum Herunterladen)

Voraussetzungen

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

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

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

IDistributedCache-Schnittstelle

Die IDistributedCache Schnittstelle bietet die folgenden Methoden zum Bearbeiten von Elementen in der verteilten Cacheimplementierung:

  • Get, GetAsync: Akzeptiert einen Zeichenfolgenschlüssel und ruft ein zwischengespeichertes Element als Array ab byte[] , wenn im Cache gefunden wird.
  • Set, SetAsync: Fügt ein Element (als byte[] Array) zum Cache mithilfe einer Zeichenfolgentaste hinzu.
  • Refresh, RefreshAsync: Aktualisiert ein Element im Cache basierend auf seinem Schlüssel, setzen Sie das gleitende Ablaufzeitout (falls vorhanden) zurück.
  • Remove, RemoveAsync: Entfernt ein Cacheelement basierend auf seinem Zeichenfolgenschlüssel.

Einrichten von verteilten Cachediensten

Registrieren einer Implementierung von IDistributedCache in Startup.ConfigureServices. In diesem Thema beschriebene Framework-Implementierungen umfassen:

Verteilter Speichercache

Der verteilte Speichercache (AddDistributedMemoryCache) ist eine frameworkbasierte Implementierung, die IDistributedCache 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 und dem Speicherverbrauch verwendet wird, ist kein Problem. Implementieren des verteilten Speichercaches abstrahierte Datenspeicher. Es ermöglicht die Implementierung einer echten verteilten Zwischenspeicherlösung in Zukunft, wenn mehrere Knoten oder Fehlertoleranz erforderlich werden.

Die Beispiel-App verwendet den verteilten Speichercache, wenn die App in der Entwicklungsumgebung Startup.ConfigureServicesausgeführt wird:

services.AddDistributedMemoryCache();

Verteilter SQL Server-Cache

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

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

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

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

Table and index were created successfully.

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

SqlServer Cache Table

Hinweis

Eine App sollte Cachewerte mithilfe einer Instanz von IDistributedCache, nicht einer SqlServerCache.

Die Beispiel-App implementiert SqlServerCache in einer Nichtentwicklungsumgebung in Startup.ConfigureServices:

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

Hinweis

Eine ConnectionString (und TableNameoptionalSchemaName) werden in der Regel außerhalb der Quellcodeverwaltung gespeichert (z. B. vom Geheimen Manager oder in appsettings.json/appsettings.{Environment}.json Dateien gespeichert). Die Verbindungszeichenfolge kann Anmeldeinformationen enthalten, die nicht aus Quellcodeverwaltungssystemen aufbewahrt werden sollten.

Verteilter Redis-Cache

Redis ist ein Open-Source-Speicher im Arbeitsspeicher, der häufig als verteilter Cache verwendet wird. Sie können einen Azure Redis-Cache für eine 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 für Redis.
  2. Kopieren Sie die Primäre Verbindungszeichenfolge (StackExchange.Redis) in Configuration.
    • Lokale Entwicklung: Speichern Sie die Verbindungszeichenfolge mit Secret Manager.
    • Azure: Speichern Sie die Verbindungszeichenfolge in der App Service-Konfiguration oder einem anderen sicheren Speicher.

Der folgende Code aktiviert den Azure-Cache für Redis:

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

    services.AddRazorPages();
}

Der vorherige Code nimmt an, dass die Primäre Verbindungszeichenfolge (StackExchange.Redis) in der Konfiguration mit dem Schlüsselnamen MyRedisConStrgespeichert 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 NCache-Cache

NCache ist ein open Source-speicherübergreifender verteilter Cache, der systemeigenen 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 "Erste Schritte" 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 Caches

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

Wenn die Beispiel-App gestartet wird, IDistributedCache wird sie injiziert Startup.Configure. Die aktuelle Zeit wird mithilfe IHostApplicationLifetime zwischengespeichert (weitere Informationen finden Sie unter Generic 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 fügt IDistributedCache sich in die Verwendung auf der IndexModel Indexseite ein.

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

Aktualisieren Sie sofort die zwischengespeicherte Zeit auf die aktuelle Uhrzeit, indem Sie die Schaltfläche " Zwischengespeicherte Zeit zurücksetzen" auswählen. Die Schaltfläche 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 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();
    }
}

Hinweis

Für Instanzen (zumindest für IDistributedCache die integrierten Implementierungen) muss keine Singleton- oder Scoped-Lebensdauer verwendet werden.

Sie können auch eine Instanz erstellen, in der Sie eine Instanz anstelle von DI benötigen, aber das Erstellen einer IDistributedCache Instanz im Code kann Ihren Code schwieriger testen und gegen das explizite Abhängigkeitsprinzip verstoßen.

Empfehlungen

Wenn Sie entscheiden, welche Implementierung 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 dem Speicher, um schnelles Abrufen zwischengespeicherter Daten bereitzustellen, aber Speicher ist eine begrenzte Ressource und kostspielig, um zu erweitern. Speichern Sie nur häufig verwendete Daten in einem Cache.

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

Wenn SQL Server als verteilter Cache-Backing-Speicher verwendet wird, kann die Verwendung derselben Datenbank für den Cache und den normalen Datenspeicher der App negativ auf die Leistung der beiden auswirken. Es wird empfohlen, eine dedizierte SQL Server-Instanz für den verteilten Cache-Backing store zu verwenden.

Zusätzliche Ressourcen