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

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 Azure-Samples/azure-cache-redis-samples på GitHub.

Förutsättningar

• Azure-prenumeration – skapa en kostnadsfritt
• Visual Studio 2019
• .NET Framework 4 eller senare, vilket krävs av StackExchange.Redis-klienten.

Skapa en cache

1. Om du vill skapa en cache loggar du in på Azure Portal. På portalmenyn väljer du Skapa en resurs.

   

2. I fönstret Kom igång anger du Azure Cache for Redis i sökfältet. I sökresultaten letar du upp Azure Cache for Redis och väljer sedan Skapa.

   

3. I fönstret Ny Redis Cache på fliken Grundläggande konfigurerar du följande inställningar för din cache:

   Inställning	Åtgärd	beskrivning
   Abonnemang	Välj din Azure-prenumerationen.	Prenumerationen som ska användas för att skapa den nya instansen av Azure Cache for Redis.
   Resursgrupp	Välj en resursgrupp eller välj Skapa ny och ange ett nytt resursgruppsnamn.	Ett namn på resursgruppen där du kan skapa cacheminnet och andra resurser. 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 på 1 till 63 tecken som endast innehåller siffror, bokstäver och bindestreck. Namnet måste börja och sluta med ett tal eller en bokstav, och det får inte innehålla bindestreck i följd. Värdnamnet för cacheinstansen är \<DNS name>.redis.cache.windows.net.
   Plats	Välj en plats.	En Azure-region som ligger nära andra tjänster som använder din cache.
   Cache-SKU	Välj en SKU.	SKU:n avgör vilka storleks-, prestanda- och funktionsparametrar som är tillgängliga för cachen. Mer information finns i Översikt över Azure Cache for Redis.
   Cachestorlek	Välj en cachestorlek.	Mer information finns i Översikt över Azure Cache for Redis.

4. Välj fliken Nätverk eller välj Nästa: Nätverk.

5. På fliken Nätverk väljer du en anslutningsmetod som ska användas för cacheminnet.

6. Välj fliken Avancerat eller välj Nästa: Avancerat.

7. I fönstret Avancerat kontrollerar eller väljer du en autentiseringsmetod baserat på följande information:

   

   • Som standard aktiveras Microsoft Entra-autentisering för en ny Basic-, Standard- eller Premium-cache och åtkomstnycklarnas autentisering inaktiveras.
   • För Basic- eller Standard-cacheminnen kan du välja valet för en icke-TLS-port.
   • För Standard- och Premium-cacheminnen kan du välja att aktivera tillgänglighetszoner. Du kan inte inaktivera tillgänglighetszoner när cacheminnet har skapats.
   • För en Premium-cache konfigurerar du inställningarna för icke-TLS-port, klustring, hanterad identitet och datapersistence.

   Viktigt!

   För optimal säkerhet rekommenderar vi att du använder Microsoft Entra-ID med hanterade identiteter för att auktorisera begäranden mot din cache om möjligt. Auktorisering med hjälp av Microsoft Entra-ID och hanterade identiteter ger överlägsen säkerhet och användarvänlighet för auktorisering av delad åtkomstnyckel. Mer information om hur du använder hanterade identiteter med din cache finns i Använda Microsoft Entra-ID för cacheautentisering.

8. (Valfritt) Välj fliken Taggar eller välj Nästa: Taggar.

9. (Valfritt) På fliken Taggar anger du ett taggnamn och värde om du vill kategorisera cacheresursen.

10. Välj knappen Granska + skapa.

    På fliken Granska + skapa verifierar Azure automatiskt din konfiguration.

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

En ny cachedistribution sker under flera minuter. Du kan övervaka förloppet för distributionen i översiktsfönstret Azure Cache for Redis. När Status visar Körs är cachen redo att användas.

Aktivera Microsoft Entra-ID-autentisering i cacheminnet

Om du har en cache kontrollerar du om Microsoft Entra-autentisering har aktiverats. Om inte aktiverar du det. Vi rekommenderar att du använder Microsoft Entra-ID för dina appar.

1. I Azure Portal väljer du den Azure Cache for Redis-instans där du vill använda Microsoft Entra-tokenbaserad autentisering.

2. Välj Autentisering på resursmenyn.

3. Kontrollera om Aktivera Microsoft Entra-autentisering är markerat i arbetsfönstret. I så fall kan du gå vidare.

4. Välj Aktivera Microsoft Entra-autentisering och ange namnet på en giltig användare. Användaren som du anger tilldelas automatiskt åtkomstprincip för dataägare som standard när du väljer Spara. Du kan också ange en hanterad identitet eller tjänstens huvudnamn för att ansluta till cacheinstansen.

   

5. En popup-dialogruta visar en fråga om du vill uppdatera konfigurationen och informerar dig om att det tar flera minuter. Välj Ja.

   Viktigt!

   När aktiveringsåtgärden är klar startas noderna i cacheinstansen om för att läsa in den nya konfigurationen. Vi rekommenderar att du utför den här åtgärden under underhållsperioden eller utanför din rusningstid. Åtgärden kan ta upp till 30 minuter.

Information om hur du använder Microsoft Entra-ID med Azure CLI finns i referenssidorna för identitet.

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

   <appSettings>
   
   <add key="RedisHostName" value="your_redis_cache_hostname"/>
   

```

1. Ersätt "your_Azure_Redis_hostname" med ditt Azure Redis-värdnamn och portnummer. Till exempel: cache-name.eastus.redis.azure.net:10000 för Azure Cache for Redis Enterprise och cache-name.redis.cache.windows.net:6380 för Azure Cache for Redis-tjänster.

2. 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 Microsoft.Azure.StackExchangeRedis
   

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

Ansluta till cachen med RedisConnection

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(redisHostName: ConfigurationManager.AppSettings["RedisHostName"].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-konsolen.>

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.

Rensa resurser

Om du vill fortsätta att använda de resurser som du skapade i den här artikeln behåller du resursgruppen.

Om du är klar med resurserna kan du ta bort den Azure-resursgrupp som du skapade för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. När du tar bort en resursgrupp tas alla resurser som ingår i den bort permanent. Kontrollera att du inte av misstag tar bort fel resursgrupp eller resurser. Om du har skapat resurserna i en befintlig resursgrupp som innehåller resurser som du vill behålla kan du ta bort varje resurs individuellt i stället för att ta bort resursgruppen.

Ta bort en resursgrupp

1. Logga in på Azure-portalen och välj Resursgrupper.

2. Välj den resursgrupp som du vill ta bort.

   Om det finns många resursgrupper använder du rutan Filter för alla fält... och skriver namnet på resursgruppen som du skapade för den här artikeln. Välj resursgruppen i resultatlistan.

   

3. Välj Ta bort resursgrupp.

4. Du blir ombedd att bekräfta borttagningen av resursgruppen. Skriv namnet på din resursgrupp för att bekräfta och välj sedan Ta bort.

   

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

Nästa steg

• Anslutningsresiliens
• Utveckling av metodtips