Avvio rapido: Usare la cache di Azure per Redis in .NET Framework

In questa guida di avvio rapido si incorpora Azure Cache for Redis in un'app .NET Framework per accedere a una cache sicura e dedicata accessibile da qualsiasi applicazione in Azure. Si usa specificamente il client StackExchange.Redis con codice C# in un'app console .NET.

Passare al codice in GitHub

Clonare il repository da (https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet in GitHub.

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito
• Visual Studio 2019
• .NET Framework 4 o versione successiva, richiesto dal client StackExchange.Redis.

Creare una cache

1. Per creare una cache, accedere al portale di Azure e selezionare Crea una risorsa.

   

2. Nella pagina Nuovo selezionare Database e quindi Cache di Azure per Redis.

   

3. Nella pagina Nuova cache Redis configurare le impostazioni per la nuova cache.

   Impostazione	Scegliere un valore	Descrizione
   Abbonamento	Nell'elenco a discesa selezionare la sottoscrizione.	Sottoscrizione in cui creare la nuova istanza della cache di Azure per Redis.
   Gruppo di risorse	Nell'elenco a discesa selezionare un gruppo di risorse oppure scegliere Crea nuovo e immettere il nome di un nuovo gruppo di risorse.	Nome del gruppo di risorse in cui creare la cache e altre risorse. L'inserimento di tutte le risorse di un'app in un unico gruppo di risorse ne semplifica la gestione o l'eliminazione.
   Nome DNS	Immettere un nome univoco.	Il nome della cache deve essere una stringa che contiene da 1 e 63 caratteri costituiti solo da numeri, lettere o trattini. Il nome deve iniziare e terminare con un numero o una lettera e non può contenere trattini consecutivi. Il nome host dell'istanza della cache è <nome DNS>.redis.cache.windows.net.
   Location	Nell'elenco a discesa selezionare una località.	Selezionare un'area in prossimità di altri servizi che useranno la cache.
   Tipo di cache	Nell'elenco a discesa selezionare un livello.	Il livello determina le dimensioni, le prestazioni e le funzionalità disponibili per la cache. Per altre informazioni, vedere la panoramica su Cache Redis di Azure.

4. Selezionare la scheda Rete o selezionare il pulsante Rete nella parte inferiore della pagina.

5. Nella scheda Rete selezionare il metodo di connettività.

6. Selezionare la scheda Avanti: Avanzate oppure selezionare il pulsante Avanti: Avanzate nella parte inferiore della pagina per visualizzare la scheda Avanzate.

   

   • Per le cache Basic o Standard, attivare o disattivare la selezione per una porta non TLS. È anche possibile selezionare se si vuole abilitare l'autenticazione di Microsoft Entra.
   • Per una cache Premium, configurare le impostazioni per la porta non TLS, il clustering, l'identità gestita e la persistenza dei dati. È anche possibile selezionare se si vuole abilitare l'autenticazione di Microsoft Entra.

7. Selezionare la scheda Avanti: Tag oppure selezionare il pulsante Avanti: Tag nella parte inferiore della pagina.

8. Facoltativamente, nella scheda Tag immettere il nome e il valore se si vuole categorizzare la risorsa.

9. Selezionare Rivedi e crea. Si viene reindirizzati alla scheda Rivedi e crea in cui Azure convalida la configurazione.

10. Quando viene visualizzato il messaggio di convalida verde, selezionare Crea.

La creazione di una cache richiede un po' di tempo. È possibile monitorare lo stato di avanzamento nella pagina Panoramica della cache di Azure per Redis. Quando l'elemento Stato indica In esecuzione, la cache è pronta per l'uso.

Recuperare il nome host, le porte e le chiavi di accesso dal portale di Azure

Per connettere il server della cache di Azure per Redis, il client della cache deve avere il nome host, le porte e una chiave per la cache. Alcuni client possono fare riferimento a questi elementi usando nomi leggermente diversi. È possibile ottenere il nome host, le porte e le chiavi dal portale di Azure.

• Per ottenere le chiavi di accesso, selezionare Chiavi di accesso nel riquadro di spostamento di sinistra della cache.

  

• Per ottenere il nome host e le porte, selezionare Proprietà nel riquadro di spostamento di sinistra della cache. Il formato del nome host è <Nome DNS>.redis.cache.windows.net.

  

1. Creare un file nel computer denominato CacheSecrets.config e inserirlo in C:\AppSecrets\CacheSecrets.config.

2. Modificare il file CacheSecrets.config e aggiungere il contenuto seguente:

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

3. Sostituire <host-name> con il nome host della cache.

4. Sostituire <access-key> con la chiave primaria per la cache.

5. Salvare il file.

Configurare il client della cache

In questa sezione, si preparerà l'applicazione console per usare il client StackExchange.Redis per .NET.

1. In Visual Studio, fare clic su Strumenti>Gestione pacchetti NuGet>Console di Gestione pacchetti ed eseguire il comando seguente dalla finestra Console di Gestione pacchetti.

   Install-Package StackExchange.Redis
   

2. Una volta completata l'installazione, il client della cache StackExchange.Redis è disponibile per l'uso con il progetto.

Connettersi alla cache dei segreti

In Visual Studio, aprire il file App.config per verificare che contenga un attributo appSettingsfile che fa riferimento al file 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>

Non archiviare mai le credenziali nel codice sorgente. Per semplificare questo esempio, viene usato solo un file di configurazione dei segreti esterno. Un approccio migliore potrebbe consistere nell'usare Azure Key Vault con certificati.

Connettersi alla cache con RedisConnection

La connessione alla cache viene gestita dalla classe RedisConnection. La connessione viene eseguita per la prima volta in questa istruzione da Program.cs:

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

Il valore dell'appSetting CacheConnection viene usato per fare riferimento alla stringa di connessione della cache dal portale di Azure come parametro password.

In RedisConnection.cs, viene visualizzato lo spazio dei nomi StackExchange.Redis con la parola chiave using. Questa operazione è necessaria per la classe RedisConnection.

using StackExchange.Redis;

Il codice RedisConnection garantisce che sia sempre presente una connessione integra alla cache gestendo l'istanza ConnectionMultiplexer da StackExchange.Redis. La classe RedisConnection ricrea la connessione quando una connessione viene persa e non è possibile riconnettersi automaticamente.

Per altre informazioni, vedere StackExchange.Redis e il codice in un repository GitHub.

Esecuzione dei comandi di cache

In program.cs, è possibile visualizzare il codice seguente per il metodo RunRedisCommandsAsync nella classe Program per l'applicazione console:

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

Per archiviare e recuperare gli elementi nella cache, è possibile usare i metodi StringSetAsync e StringGetAsync.

Nell'esempio è possibile vedere che la chiave Message è impostata su Value. L'app ha aggiornato questo valore memorizzato nella cache. L'app ha anche eseguito PING e il comando.

Gestire gli oggetti .NET nella cache

Il server Redis archivia la maggior parte dei dati come stringhe, tuttavia queste stringhe possono contenere molti tipi di dati, tra cui dati binari serializzati, utilizzabili durante l'archiviazione di oggetti .NET nella cache.

Cache Redis di Azure è in grado di memorizzare nella cache sia oggetti .NET che tipi di dati primitivi, ma prima della memorizzazione nella cache un oggetto .NET deve essere serializzato.

La serializzazione di un oggetto .NET spetta allo sviluppatore dell'applicazione, che può scegliere liberamente il serializzatore da usare.

Un modo semplice per serializzare gli oggetti prevede l'uso dei metodi di serializzazione JsonConvert in System.text.Json.

Aggiungere lo spazio dei nomi System.text.Json a Visual Studio:

1. Selezionare Strumenti>Gestione Pacchetti NuGet>Console di Gestione pacchetti.

2. Nella finestra Console di Gestione pacchetti eseguire quindi il comando seguente.

   Install-Package system.text.json
   

La classe Employee seguente è stata definita in Program.cs in modo che l'esempio possa anche mostrare come ottenere e impostare un oggetto serializzato:

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;
    }
}

Eseguire l'esempio

Premere CTRL+F5 per compilare ed eseguire l'app console per testare la serializzazione degli oggetti .NET.

Pulire le risorse

Se si continua a usare questo avvio rapido, è possibile mantenere le risorse create e riutilizzarle.

In caso contrario, se si è terminato il lavoro con l'applicazione di esempio di avvio rapido, è possibile eliminare le risorse di Azure create in questo avvio rapido per evitare i costi correlati.

Accedere al portale di Azure e selezionare Gruppi di risorse.

Nella casella di testo Filtra per nome... immettere il nome del gruppo di risorse. Le istruzioni di questo articolo usano un gruppo di risorse denominato TestResources. Nel gruppo di risorse nell'elenco dei risultati selezionare ... e quindi Elimina gruppo di risorse.

Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Digitare il nome del gruppo di risorse per confermare e selezionare Elimina.

Dopo qualche istante il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Passaggi successivi

• Resilienza della connessione
• Sviluppo di procedure consigliate