Zelfstudie: Caching implementeren met .NET.NET Aspire-integraties

Artikel
12/15/2024

Cloudeigen apps vereisen vaak verschillende soorten schaalbare cachingoplossingen om de prestaties te verbeteren. .NET Aspire integraties vereenvoudigen het proces van het maken van verbinding met populaire cachingservices zoals Redis. In dit artikel leert u het volgende:

Maak een eenvoudige ASP.NET kern-app die is ingesteld voor het gebruik van .NET Aspire.
Voeg .NET Aspire integraties toe om verbinding te maken met Redis en caching te implementeren.
Configureer de .NET.NET Aspire-integraties om te voldoen aan specifieke vereisten.

In dit artikel wordt beschreven hoe u twee verschillende typen ASP.NET Core caching gebruikt met behulp van .NET Aspire en Redis:

uitvoercache: een configureerbare, uitbreidbare cachemethode voor het opslaan van volledige HTTP-antwoorden voor toekomstige aanvragen.
gedistribueerde cache: een cache die wordt gedeeld door meerdere app-servers waarmee u specifieke gegevens kunt opslaan in de cache. Een gedistribueerde cache wordt doorgaans onderhouden als een externe service voor de app-servers die er toegang toe hebben en kan de prestaties en schaalbaarheid van een ASP.NET Core-app verbeteren.

Voorwaarden

Als u met .NET.NET Aspirewilt werken, hebt u het volgende lokaal geïnstalleerd:

.NET 8,0 of .NET 9,0
Een OCI-compatibele containerruntime, zoals:
- Docker Desktop of Podman. Voor meer informatie, zie Container runtime.
Een IDE (Integrated Developer Environment) of code-editor, zoals:
- Visual Studio 2022 versie 17.9 of hoger (optioneel)
- Visual Studio Code (optioneel)
  - C# Dev Kit: extensie- (optioneel)
- JetBrains Rider met .NET.NET Aspire plugin (optioneel)

Zie .NET.NET Aspire setup en hulpprogramma'sen .NET.NET Aspire SDK-voor meer informatie.

Het project maken

Ga boven in Visual Studionaar Bestand>Nieuw>Project....
Voer in het dialoogvenster .NET Aspire in het zoekvak van de projectsjabloon in en selecteer .NET.NET Aspire Starttoepassing. Kies Volgende.
Op het scherm 'Uw nieuwe project configureren':
- Voer een projectnaam vanAspireRedisin.
- Laat de rest van de waarden op de standaardwaarden staan en selecteer Volgende.
Op het scherm Aanvullende informatie:
- Zorg ervoor dat .NET 9,0 is geselecteerd.
- Haal het vinkje weg bij Gebruik Redis voor caching van. U implementeert uw eigen cache-installatie.
- Selecteer , maakaan.

Visual Studio maakt een nieuwe .NET Aspire oplossing die uit de volgende projecten bestaat:

AspireRedis.Web - Een Blazor UI-project met standaardconfiguraties .NET Aspire.
AspireRedis.ApiService - Een minimale API met standaardconfiguraties .NET.NET Aspire die de front-end met gegevens biedt.
AspireRedis.AppHost - Een orchestratorproject dat is ontworpen om de verschillende projecten en services van uw app te verbinden en te configureren.
AspireRedis.ServiceDefaults - Een .NET.NET Aspire gedeeld project voor het beheren van configuraties die opnieuw worden gebruikt in de projecten in uw oplossing met betrekking tot tolerantie, servicedetectieen telemetrie.

Het app-hostproject configureren

Voeg de 📦Aspire.Hosting.Redis NuGet-pakket aan het AspireRedis.AppHost-project toe.
- .NET CLI
- PackageReference
```
dotnet add package Aspire.Hosting.Redis
```
```
<PackageReference Include="Aspire.Hosting.Redis"
                  Version="*" />
```
Zie dotnet pakket toevoegen of Pakketafhankelijkheden beheren in .NET toepassingenvoor meer informatie.

Werk het Program.cs bestand van het AspireRedis.AppHost project bij zodat deze overeenkomt met de volgende code:

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();

Met de voorgaande code maakt u een lokale Redis containerinstantie en configureert u de gebruikersinterface en API om het exemplaar automatisch te gebruiken voor zowel uitvoer als gedistribueerde caching. De code configureert ook de communicatie tussen de front-endgebruikersinterface en de back-end-API met behulp van servicedetectie. Met de impliciete servicedetectie van .NET.NET Aspireis het instellen en beheren van serviceverbindingen gestroomlijnd voor productiviteit van ontwikkelaars. In de context van deze zelfstudie vereenvoudigt de functie hoe u verbinding maakt met Redis.

Normaal gesproken geeft u handmatig de Redis verbindingsreeks op in het appsettings.json-bestand van elk project:

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

Voor het configureren van de verbindingsreeks met deze methode, terwijl deze functioneel is, moet de verbindingsreeks in meerdere projecten worden gedupliceerd. Dit kan omslachtig en foutgevoelig zijn.

De gebruikersinterface configureren met uitvoercache

Voeg de .NET Aspire Stack Exchange Redis output-caching integratiepakketten toe aan uw AspireRedis.Web-app:
```
dotnet add package Aspire.StackExchange.Redis.OutputCaching
```
Voeg in het Program.cs-bestand van het AspireRedis.WebBlazor project, direct na de regel var builder = WebApplication.CreateBuilder(args);, een aanroep toe aan de AddRedisOutputCache-extensiemethode:
```
builder.AddRedisOutputCache("cache");
```
Met deze methode worden de volgende taken uitgevoerd:
- Hiermee configureert u ASP.NET Core uitvoercache voor het gebruik van een Redis exemplaar met de opgegeven verbindingsnaam.
- Hiermee worden automatisch bijbehorende statuscontroles, logboekregistratie en telemetrie ingeschakeld.
Vervang de inhoud van het bestand Home.razor van het AspireRedis.WebBlazor project door het volgende:
```
@page "/"
@attribute [OutputCache(Duration = 10)]

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

Welcome to your new app on @DateTime.Now
```
De integratie bevat het kenmerk [OutputCache], waarmee het volledige gerenderde antwoord in de cache wordt opgeslagen. De pagina bevat ook een aanroep naar @DateTime.Now om te controleren of het antwoord in de cache is opgeslagen.

De API configureren met gedistribueerde caching

Voeg de .NET Aspire Stack Exchange Redis gedistribueerde caching--integratiepakketten toe aan uw AspireRedis.ApiService-app:
```
dotnet add package Aspire.StackExchange.Redis.DistributedCaching
```
Voeg boven aan het Program.cs-bestand een aanroep toe aan AddRedisDistributedCache:
```
builder.AddRedisDistributedCache("cache");
```

Voeg in het bestand Program.cs de volgende using instructies toe:

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

Vervang in het bestand Program.cs de bestaande /weatherforecast-eindpuntcode door het volgende:

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");

De app lokaal testen

Test het cachegedrag van uw app met behulp van de volgende stappen:

Voer de app uit met Visual Studio door op F5te drukken.
Als het Start Docker Bureaublad-dialoogvenster wordt weergegeven, selecteert u Ja om de service te starten.
Het .NET.NET Aspire Dashboard wordt geladen in de browser en vermeldt de gebruikersinterface- en API-projecten.

Test de uitvoercache:

Klik op de pagina projecten in de rij webfrontend op de localhost koppeling in de kolom Eindpunten om de gebruikersinterface van uw app te openen.
De toepassing geeft de huidige tijd weer op de startpagina.
Vernieuw de browser elke paar seconden om dezelfde pagina te zien die wordt geretourneerd door de outputcache. Na 10 seconden verloopt de cache en wordt de pagina opnieuw geladen met een bijgewerkte tijd.

De gedistribueerde cache testen:

Navigeer naar de pagina Weather in de gebruikersinterface van Blazor om een tabel met gerandomiseerde weergegevens te laden.
Vernieuw de browser om de paar seconden om dezelfde weergegevens te zien die worden geretourneerd door uitvoercache. Na 10 seconden verloopt de cache en wordt de pagina opnieuw geladen met bijgewerkte weergegevens.

Gefeliciteerd! U hebt een ASP.NET Core-app geconfigureerd om uitvoer- en gedistribueerde caching met .NET Aspirete gebruiken.

Delen via