Snabbstart: Så här använder du Azure Cache for Redis i .NET Framework

  • Artikel

I den här snabbstarten införlivar du Azure Cache for Redis i en .NET Framework-app för att få åtkomst till en säker, dedikerad cache som är tillgänglig från alla program i Azure. Du använder specifikt StackExchange.Redis-klienten med C#-kod i en .NET-konsolapp.

Hoppa till koden på GitHub

Klona lagringsplatsen från (https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet på GitHub.

Förutsättningar

Skapa en cache

  1. Om du vill skapa en cache loggar du in på Azure-portalen och väljer Skapa en resurs.

    Skapa en resurs är markerad i det vänstra navigeringsfönstret.

  2. På sidan Nytt väljer du Databaser och sedan Azure Cache for Redis.

    På Ny markeras databaser och Azure Cache for Redis markeras.

  3. På sidan Ny Redis Cache konfigurerar du inställningarna för din nya cache.

    Inställning Välj ett värde beskrivning
    Abonnemang Listrutan och välj din prenumeration. Prenumerationen som den nya Azure Cache for Redis-instansen ska skapas under.
    Resursgrupp Listrutan och välj en resursgrupp eller välj Skapa ny och ange ett nytt resursgruppsnamn. Namn på den resursgrupp där cacheminnet och andra resurser ska skapas. Genom att placera alla dina appresurser i en resursgrupp kan du enkelt hantera eller ta bort dem tillsammans.
    DNS-namn Ange ett unikt namn. Cachenamnet måste vara en sträng mellan 1 och 63 tecken som endast innehåller siffror, bokstäver eller bindestreck. Namnet måste börja och sluta med ett tal eller en bokstav och får inte innehålla bindestreck i följd. Värdnamnet för cacheinstansen är <DNS-namnet.redis.cache.windows.net>.
    Plats Listrutan och välj en plats. Välj en region nära andra tjänster som använder din cache.
    Cachetyp Listrutan och välj en nivå. Nivån avgör storlek, prestanda och funktioner som är tillgängliga för cacheminnet. Mer information finns i Översikt över Azure Cache for Redis.

  4. Välj fliken Nätverk eller välj knappen Nätverk längst ned på sidan.

  5. På fliken Nätverk väljer du din anslutningsmetod.

  6. Välj fliken Nästa: Avancerat eller välj knappen Nästa: Avancerat längst ned på sidan för att se fliken Avancerat .

    Skärmbild som visar fliken Avancerat i arbetsfönstret och det tillgängliga alternativet att välja.

    • För Basic- eller Standard-cacheminnen växlar du markeringen för en icke-TLS-port. Du kan också välja om du vill aktivera Microsoft Entra-autentisering.
    • För en Premium-cache konfigurerar du inställningarna för icke-TLS-port, klustring, hanterad identitet och datapersistence. Du kan också välja om du vill aktivera Microsoft Entra-autentisering.

  7. Välj fliken Nästa: Taggar eller välj knappen Nästa: Taggar längst ned på sidan.

  8. Du kan också ange namn och värde på fliken Taggar om du vill kategorisera resursen.

  9. Välj Granska + skapa. Du kommer till fliken Granska + skapa där Azure verifierar din konfiguration.

  10. När det gröna verifieringsmeddelandet har skickats väljer du Skapa.

Det tar en stund innan en cache skapas. Du kan övervaka förloppet på översiktssidan för Azure Cache for Redis. När Status visas som Körs är cachen redo att användas.

Hämta värdnamn, portar och åtkomstnycklar från Azure-portalen

För att ansluta din Azure Cache for Redis-server behöver cacheklienten värdnamnet, portarna och en nyckel för cachen. Vissa klienter kan hänvisa till dessa objekt med namn som skiljer sig något. Du kan hämta värdnamnet, portarna och nycklarna från Azure-portalen.

  • Om du vill hämta åtkomstnycklarna väljer du Autentisering på resursmenyn. Välj sedan fliken Åtkomstnycklar .

    Nycklar för Azure Cache for Redis

  • Om du vill hämta värdnamnet och portarna för cacheminnet väljer du Översikt på resursmenyn. Värdnamnet är av formatet DNS name.redis.cache.windows.net>.<

    Egenskaper för Azure Cache for Redis

  1. Skapa en fil på datorn med namnet CacheSecrets.config och placera den C:\AppSecrets\CacheSecrets.config.

  2. Redigera filen CacheSecrets.config och lägg till följande innehåll:

    <appSettings>
    <add key="CacheConnection" value="<host-name>,abortConnect=false,ssl=true,allowAdmin=true,password=<access-key>"/>
</appSettings>

  3. Ersätt <host-name> med din cachens värdnamn.

  4. Ersätt <access-key> med primärnyckeln för cachen.

  5. Spara filen.

Konfigurera cacheklienten

I det här avsnittet förbereder du konsolprogrammet för att använda StackExchange.Redis-klienten för .NET.

  1. I Visual Studio väljer du Verktyg>NuGet Package Manager Package Manager-konsolen> och kör följande kommando från fönstret Package Manager-konsol.

    Install-Package StackExchange.Redis

  2. När installationen är klar är StackExchange.Redis-klienten redo för användning med ditt projekt.

Anslut till cacheminnet för hemligheter

Öppna filen App.config i Visual Studio för att kontrollera att den innehåller ett appSettingsfile attribut som refererar till filen CacheSecrets.config.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>

    <appSettings file="C:\AppSecrets\CacheSecrets.config"></appSettings>
</configuration>

Lagra aldrig autentiseringsuppgifterna i källkoden. För att hålla det här exemplet enkelt använder vi en konfigurationsfil för externa hemligheter. En bättre metod är att använda Azure Key Vault med certifikat.

Anslut till cachen med Redis Anslut ion

Anslutningen till cachen hanteras av RedisConnection klassen. Anslutningen görs först i den här instruktionen från Program.cs:

     _redisConnection = await RedisConnection.InitializeAsync(connectionString: ConfigurationManager.AppSettings["CacheConnection"].ToString());

Värdet för appinställningen CacheConnection används för att referera till cache-anslutningssträngen från Azure-portalen som lösenordsparameter.

I RedisConnection.csvisas StackExchange.Redis namnområdet med nyckelordet using . Detta krävs för RedisConnection klassen.

using StackExchange.Redis;

Koden RedisConnection säkerställer att det alltid finns en felfri anslutning till cachen genom att hantera instansen ConnectionMultiplexer från StackExchange.Redis. Klassen RedisConnection återskapar anslutningen när en anslutning går förlorad och det inte går att återansluta automatiskt.

Mer information finns i StackExchange.Redis och koden i en GitHub-lagringsplats.

Utföra cache-kommandon

I program.cskan du se följande kod för RunRedisCommandsAsync metoden i Program -klassen för konsolprogrammet:

private static async Task RunRedisCommandsAsync(string prefix)
    {
        // Simple PING command
        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: PING");
        RedisResult pingResult = await _redisConnection.BasicRetryAsync(async (db) => await db.ExecuteAsync("PING"));
        Console.WriteLine($"{prefix}: Cache response: {pingResult}");

        // Simple get and put of integral data types into the cache
        string key = "Message";
        string value = "Hello! The cache is working from a .NET console app!";

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: GET {key} via StringGetAsync()");
        RedisValue getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync(key));
        Console.WriteLine($"{prefix}: Cache response: {getMessageResult}");

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: SET {key} \"{value}\" via StringSetAsync()");
        bool stringSetResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringSetAsync(key, value));
        Console.WriteLine($"{prefix}: Cache response: {stringSetResult}");

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: GET {key} via StringGetAsync()");
        getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync(key));
        Console.WriteLine($"{prefix}: Cache response: {getMessageResult}");

        // Store serialized object to cache
        Employee e007 = new Employee("007", "Davide Columbo", 100);
        stringSetResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringSetAsync("e007", JsonSerializer.Serialize(e007)));
        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache response from storing serialized Employee object: {stringSetResult}");

        // Retrieve serialized object from cache
        getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync("e007"));
        Employee e007FromCache = JsonSerializer.Deserialize<Employee>(getMessageResult);
        Console.WriteLine($"{prefix}: Deserialized Employee .NET object:{Environment.NewLine}");
        Console.WriteLine($"{prefix}: Employee.Name : {e007FromCache.Name}");
        Console.WriteLine($"{prefix}: Employee.Id   : {e007FromCache.Id}");
        Console.WriteLine($"{prefix}: Employee.Age  : {e007FromCache.Age}{Environment.NewLine}");
    }

Cacheobjekt kan lagras i och hämtas med hjälp av StringSetAsync- och StringGetAsync-metoderna.

I exemplet kan du se att Message nyckeln är inställd på värde. Appen uppdatera det cachelagrade värdet. Appen körde PING också kommandot och .

Arbeta med .NET-objekt i cachen

Redis-servern lagrar de flesta data som strängar, men dessa strängar kan innehålla många typer av data, inklusive serialiserade binära data, som kan användas när .NET-objekt lagras i cacheminnet.

Azure Cache for Redis kan cachelagra både .NET-objekt och basdatatyper, men .NET-objekt måste serialiseras innan de kan cachelagras.

Den här .NET-objektserialiseringen är programutvecklarens ansvar och ger utvecklaren flexibilitet i valet av serialiserare.

Ett enkelt sätt att serialisera objekt är att använda serialiseringsmetoderna JsonConvert i System.text.Json.

Lägg till namnområdet i System.text.Json Visual Studio:

  1. Välj Verktyg>NuGet Package Manager Package Manager>Console*.

  2. Kör sedan följande kommando från package manager-konsolfönstret.

    Install-Package system.text.json

Följande Employee klass definierades i Program.cs så att exemplet också kunde visa hur du hämtar och anger ett serialiserat objekt :

class Employee
{
    public string Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }

    public Employee(string employeeId, string name, int age)
    {
        Id = employeeId;
        Name = name;
        Age = age;
    }
}

Kör exemplet

Tryck på Ctrl + F5 att skapa och köra konsolappen om du vill testa serialisering av .NET-objekt.

Konsolappen har slutförts

Rensa resurser

Om du fortsätter att använda den här snabbstarten kan du behålla de resurser som skapats och återanvända dem.

Om du är klar med exempelappen för snabbstart kan du ta bort Azure-resurserna som du skapade i snabbstarten för att undvika kostnader.

Viktigt!

Det går inte att ångra borttagningen av en resursgrupp och att resursgruppen och alla resurser i den tas bort permanent. Kontrollera att du inte av misstag tar bort fel resursgrupp eller resurser. Om du har skapat resurserna för att vara värd för det här exemplet i en befintlig resursgrupp som innehåller resurser som du vill behålla kan du ta bort varje resurs individuellt till vänster i stället för att ta bort resursgruppen.

Logga in på Azure Portal och välj Resursgrupper.

Skriv namnet på din resursgrupp i textrutan Filter by name... (Filtrera efter namn...). Anvisningarna för den här artikeln använde en resursgrupp med namnet TestResources. I resursgruppen i resultatlistan väljer du ... och sedan Ta bort resursgrupp.

Delete

Du uppmanas att bekräfta borttagningen av resursgruppen. Skriv namnet på resursgruppen för att bekräfta och välj Ta bort.

Efter en liten stund tas resursgruppen och resurser som finns i den bort.

Nästa steg