Tutorial: Implementierung von Caching mit .NET- und.NET Aspire-Integrationen

Artikel
02/05/2025

Cloudeigene Apps erfordern häufig verschiedene Arten skalierbarer Caching-Lösungen, um die Leistung zu verbessern. .NET Aspire-Integrationen vereinfachen den Prozess der Verbindung mit beliebten Caching-Diensten wie Redis. In diesem Artikel erfahren Sie, wie Sie:

Erstellen Sie eine einfache ASP.NET-Kernanwendung, die für die Verwendung von .NET Aspirekonfiguriert ist.
Fügen Sie .NET Aspire Integrationen hinzu, um eine Verbindung mit Redis herzustellen und Zwischenspeicherung zu implementieren.
Konfigurieren Sie die .NET.NET Aspire Integrationen so, dass sie bestimmte Anforderungen erfüllen.

In diesem Artikel wird erkundet, wie Sie zwei verschiedene Arten von ASP.NET Core Caching mit .NET Aspire und Redisverwenden.

Ausgabezwischenspeicherung: Eine konfigurierbare, erweiterbare Zwischenspeicherungsmethode zum Speichern vollständiger HTTP-Antworten für zukünftige Anforderungen.
verteilte Zwischenspeicherung: Ein von mehreren App-Servern gemeinsam genutzter Cache, mit dem Sie bestimmte Datenabschnitte zwischenspeichern können. Ein verteilter Cache wird in der Regel als externer Dienst für die App-Server verwaltet, die darauf zugreifen und die Leistung und Skalierbarkeit einer ASP.NET Core-App verbessern können.

Voraussetzungen

Um mit .NET.NET Aspirezu arbeiten, benötigen Sie folgendes lokal installiert:

.NET 8.0 oder .NET 9,0
Eine OCI-kompatible Containerlaufzeit, z. B.:
- Docker Desktop oder Podman. Weitere Informationen finden Sie unter container runtime.
Eine integrierte Entwicklerumgebung (Integrated Developer Environment, IDE) oder ein Code-Editor, z. B.:
- Visual Studio 2022 Version 17.9 oder höher (optional)
- Visual Studio Code (optional)
  - C# Dev Kit: Erweiterung (Optional)
- JetBrains Rider mit .NET.NET Aspire Plugin (optional)

Weitere Informationen finden Sie unter .NET.NET Aspire Setup- und Werkzeugsowie .NET.NET Aspire SDK -.

Projekt erstellen

Navigieren Sie oben in Visual Studiozu Datei>Neues>Projekt....
Geben Sie im Dialogfeld .NET Aspire in das Suchfeld der Projektvorlage ein, und wählen Sie .NET.NET Aspire Startanwendungaus. Wählen Sie Weiteraus.
Auf dem Bildschirm "Konfigurieren des neuen Projekts":
- Geben Sie einen Projektnamen von AspireRedisein.
- Behalten Sie die restlichen Werte bei ihren Standardwerten bei, und wählen Sie Nextaus.
Auf dem Bildschirm Zusätzliche Informationen:
- Stellen Sie sicher, dass .NET 9,0 ausgewählt ist.
- Deaktivieren Sie . Verwenden Sie Redis zum Zwischenspeichern von. Sie implementieren Ihre eigene Caching-Konfiguration.
- Wählen Sie Erstellenaus.

Visual Studio erstellt eine neue .NET Aspire Lösung, die aus den folgenden Projekten besteht:

AspireRedis.Web – Ein Blazor UI-Projekt mit Standardkonfigurationen .NET Aspire.
AspireRedis.ApiService – Eine minimale API mit Standardkonfigurationen .NET.NET Aspire, die das Frontend mit Daten bereitstellt.
AspireRedis.AppHost- – Ein Orchestratorprojekt, das entwickelt wurde, um die verschiedenen Projekte und Dienste Ihrer App zu verbinden und zu konfigurieren.
AspireRedis.ServiceDefaults – Ein .NET.NET Aspire gemeinsames Projekt zum Verwalten von Konfigurationen, die in Ihren Projekten in Ihrer Lösung im Zusammenhang mit Resilienz, Dienstermittlungund Telemetriewiederverwendet werden.

Konfigurieren des App-Hostprojekts

Fügen Sie das NuGet-Paket 📦Aspire.Hosting.Redis zum AspireRedis.AppHost-Projekt hinzu:
- .NET CLI
- PackageReference
```
dotnet add package Aspire.Hosting.Redis
```
```
<PackageReference Include="Aspire.Hosting.Redis"
                  Version="*" />
```
Weitere Informationen finden Sie unter dotnet add package oder Verwalten von Paketabhängigkeiten in .NET Anwendungen.

Aktualisieren Sie die Program.cs Datei des AspireRedis.AppHost Projekts so, dass sie dem folgenden Code entspricht:

var builder = DistributedApplication.CreateBuilder(args);

var redis = builder.AddRedis("cache");

var apiservice = builder.AddProject<Projects.AspireRedis_ApiService>("apiservice")
    .WithReference(redis);

builder.AddProject<Projects.AspireRedis_Web>("webfrontend")
    .WithExternalHttpEndpoints()
    .WithReference(apiservice)
    .WithReference(redis);

builder.Build().Run();

Der vorangehende Code erstellt eine lokale Redis Containerinstanz und konfiguriert die Benutzeroberfläche und API für die automatische Verwendung der Instanz sowohl für die Ausgabe als auch für die verteilte Zwischenspeicherung. Der Code konfiguriert außerdem die Kommunikation zwischen der Frontend-Benutzeroberfläche und der Back-End-API mithilfe der Dienstermittlung. Mit der impliziten Erkennung von Diensten .NET.NET Aspirewird das Einrichten und Verwalten von Dienstverbindungen optimiert, um die Produktivität der Entwickler zu steigern. Im Kontext dieses Lernprogramms vereinfacht das Feature, wie Sie eine Verbindung mit Redisherstellen.

Traditionell geben Sie die Redis-Verbindungszeichenfolge manuell in der appsettings.json-Datei jedes Projekts an.

{
  "ConnectionStrings": {
    "cache": "localhost:6379"
  }
}

Das Konfigurieren der Verbindungszeichenfolge mit dieser Methode erfordert, während sie funktionsfähig ist, die Verbindungszeichenfolge über mehrere Projekte hinweg zu duplizieren, was umständlich und fehleranfällig sein kann.

Konfigurieren Sie die Benutzeroberfläche mit Ausgabecaching

Fügen Sie ihrer .NET Aspire-App die Redis Integrationspakete hinzu:
```
dotnet add package Aspire.StackExchange.Redis.OutputCaching
```
Fügen Sie in der datei Program.cs des AspireRedis.WebBlazor Projekts unmittelbar nach der Zeile var builder = WebApplication.CreateBuilder(args);einen Aufruf der AddRedisOutputCache Erweiterungsmethode hinzu:
```
builder.AddRedisOutputCache("cache");
```
Diese Methode führt die folgenden Aufgaben aus:
- Konfiguriert das Caching der ASP.NET Core-Ausgabe so, dass es eine Redis-Instanz mit dem angegebenen Verbindungsnamen verwendet.
- Aktiviert automatisch entsprechende Integritätsprüfungen, Protokollierung und Telemetrie.
Ersetzen Sie den Inhalt der Home.razor Datei des AspireRedis.WebBlazor Projekts durch Folgendes:
```
@page "/"
@attribute [OutputCache(Duration = 10)]

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

Welcome to your new app on @DateTime.Now
```
Die Integration umfasst das [OutputCache]-Attribut, das die gesamte gerenderte Antwort zwischenspeichert. Die Seite schließt auch einen Aufruf von @DateTime.Now ein, um zu überprüfen, ob die Antwort zwischengespeichert ist.

Konfigurieren der API mit verteilter Zwischenspeicherung

Fügen Sie ihrer .NET Aspire-App die Redis Integrationspakete hinzu:
```
dotnet add package Aspire.StackExchange.Redis.DistributedCaching
```
Fügen Sie oben in der Program.cs-Datei einen Aufruf von AddRedisDistributedCachehinzu:
```
builder.AddRedisDistributedCache("cache");
```

Fügen Sie in Datei Program.cs die folgenden Anweisungen using hinzu:

using System.Text;
using System.Text.Json;
using Microsoft.Extensions.Caching.Distributed;

Ersetzen Sie in der datei Program.cs den vorhandenen /weatherforecast Endpunktcode durch Folgendes:

app.MapGet("/weatherforecast", async (IDistributedCache cache) =>
{
    var cachedForecast = await cache.GetAsync("forecast");

    if (cachedForecast is null)
    {
        var summaries = new[] { "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" };
        var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();

        await cache.SetAsync("forecast", Encoding.UTF8.GetBytes(JsonSerializer.Serialize(forecast)), new ()
        {
            AbsoluteExpiration = DateTime.Now.AddSeconds(10)
        });

        return forecast;
    }

    return JsonSerializer.Deserialize<IEnumerable<WeatherForecast>>(cachedForecast);
})
.WithName("GetWeatherForecast");

Testen der App lokal

Testen Sie das Zwischenspeicherungsverhalten Ihrer App mithilfe der folgenden Schritte:

Führen Sie die App mit Visual Studio aus, indem Sie F5drücken.
Wenn das Dialogfeld Start Docker Desktop- angezeigt wird, wählen Sie Ja- aus, um den Dienst zu starten.
Das .NET.NET Aspire Dashboard wird im Browser geladen und listet die UI- und API-Projekte auf.

Testen Sie den Ausgabecache:

Klicken Sie auf der Projektseite in der Zeile Webfrontend auf den Link localhost in der Spalte Endpunkte, um die Benutzeroberfläche Ihrer App zu öffnen.
Die Anwendung zeigt die aktuelle Uhrzeit auf der Startseite an.
Aktualisieren Sie den Browser alle paar Sekunden, um die gleiche Seite anzuzeigen, die von der Ausgabezwischenspeicherung zurückgegeben wird. Nach 10 Sekunden läuft der Cache ab und die Seite wird mit einer aktualisierten Zeit neu geladen.

Testen Sie den verteilten Cache:

Navigieren Sie zur Seite Wetter auf der Blazor UI, um eine Tabelle mit zufälligen Wetterdaten zu laden.
Aktualisieren Sie den Browser alle paar Sekunden, um die identischen Wetterdaten zu sehen, die durch die Ausgabezwischenspeicherung bereitgestellt werden. Nach 10 Sekunden läuft der Cache ab und die Seite wird mit aktualisierten Wetterdaten neu geladen.

Glückwunsch! Sie haben eine ASP.NET Core-App so konfiguriert, dass Ausgabe- und verteilte Zwischenspeicherung mit .NET Aspireverwendet werden.

Freigeben über