1. L’appel sous‑jacent IDatabase.StringSet() écrit des données de type chaîne dans Redis
2. Logique de sérialisation : objet arbitraire → chaîne JSON → tableau d’octets UTF‑8 stocké dans Redis
3. Logique de désérialisation : lecture du tableau d’octets → chaîne JSON → objet générique cible
4. Valeur de retour : true = réussi, false = échec

Espaces de noms à importer

using StackExchange.Redis;
using Newtonsoft.Json;
using System.Text;

L’exemple ci‑dessous utilise Set : on transmet une clé, un tableau d’octets et une durée d’expiration.

/// <summary>
/// Écrire une entrée dans le cache Redis
/// </summary>
/// <param name="key">Clé de cache</param>
/// <param name="data">Objet quelconque</param>
/// <param name="cacheTime">Durée d’expiration 【minutes】</param>
/// <returns>true réussi / false échec</returns>
private bool Set(string key, object data, int cacheTime)
{
    if (data == null)
    {
        return false;
    }
    byte[] entryBytes = Serialize(data);
    TimeSpan expiresIn = TimeSpan.FromMinutes(cacheTime);
    return db.StringSet(key, entryBytes, expiresIn);
}

/// <summary>
/// Sérialisation d’objet : object → byte[]
/// </summary>
private byte[] Serialize(object data)
{
    string json = JsonConvert.SerializeObject(data);
    return Encoding.UTF8.GetBytes(json);
}

/// <summary>
/// Lire le cache à partir d’une clé
/// </summary>
/// <typeparam name="T">Type cible</typeparam>
/// <param name="key">Clé de cache</param>
/// <returns>Retourne default(T) si la clé n’existe pas</returns>
public T Get<T>(string key)
{
    RedisValue rValue = db.StringGet(key);
    if (!rValue.HasValue)
    {
        return default(T);
    }
    T result = Deserialize<T>(rValue);
    return result;
}

/// <summary>
/// Désérialisation : byte[] → objet de type T
/// </summary>
private T Deserialize<T>(byte[] serializedObject)
{
    if (serializedObject == null)
    {
        return default(T);
    }
    string json = Encoding.UTF8.GetString(serializedObject);
    return JsonConvert.DeserializeObject<T>(json);
}

Remarques

1. Unité de temps
   Dans le code TimeSpan.FromMinutes(cacheTime) signifie que la valeur fournie est exprimée en 【minutes】
   Si vous appelez Set(key,val,1000) depuis votre formulaire, le cache expirera au bout de 1000 minutes, pas en secondes !

L’exemple du formulaire utilisait la valeur codée en dur 1000, c’est une erreur fréquente.
Si vous voulez utiliser des secondes, remplacez‑le par TimeSpan.FromSeconds(cacheTime)

2. Installation des dépendances
   Installez ces deux paquets NuGet :

• StackExchange.Redis
• Newtonsoft.Json

2. Format de stockage des données
   Tous les objets sont sérialisés en binaire JSON et sauvegardés dans Redis ; ce que vous voyez dans un client Redis est du texte JSON standard.
3. Compatibilité RedisValue
db.StringGet(key) renvoie un RedisValue, qui se convertit implicitement en byte[] et peut être passé directement à Deserialize<T>.
4. Conseil sur la sécurité des threads
   IConnectionMultiplexer doit être un singleton global. Ne créez pas une nouvelle connexion à chaque lecture‑écriture Redis.

Exemple d’utilisation

// Écrire une entrée (expire au bout de 30 minutes)
bool ok = Set("user:1001", new {Id = 1001, Name = "test"}, 30);

// Lire la valeur
var user = Get<dynamic>("user:1001");

// Exemple de lecture d’un modèle d’entité
// var model = Get<UserInfo>("user:1001");

Recommandations

Extrayez ces méthodes d’assistance et le code de connexion Redis dans une classe statique séparée RedisHelper.cs. Évitez de les placer dans le code‑behind du formulaire pour séparer les responsabilités.

Écrire une valeur

Une fois installé, Redis s’exécute comme un service indépendant. Pour l’utiliser en C# WinForms, vous devez vous y connecter, de la même manière qu’avec une base de données classique.

La chaîne de connexion ci‑dessous est placée dans le fichier app.config

1. Configuration App.config

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <connectionStrings>
    <!-- Chaîne de connexion Redis -->
    <add name="RedisConnectionString" connectionString="127.0.0.1:6379"/>
    <!-- Forme courte connectionString="localhost" port par défaut 6379 -->
  </connectionStrings>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>
</configuration>

Explication de la chaîne de connexion

• localhost / 127.0.0.1：Service Redis local
• Port par défaut 6379 ; pour un port différent : 127.0.0.1:6380
• Si Redis est protégé par un mot‑de‑passe : 127.0.0.1:6379,password=votremotdepasse

2. Code principal Form1.cs

Paquet NuGet requis

StackExchange.Redis

Espaces de noms à importer

using StackExchange.Redis;
using System.Configuration;

public partial class Form1 : Form
{
    // Objet d'accès à la base Redis
    private IDatabase db;
    // Lecture de la chaîne de connexion depuis le fichier de configuration
    private string ConnectionString = ConfigurationManager.ConnectionStrings["RedisConnectionString"].ConnectionString;
    // Connexion multiplexée (singleton recommandé par l'éditeur, volatile pour la sécurité des threads)
    private volatile IConnectionMultiplexer connection;

    public Form1()
    {
        InitializeComponent();
        // Créer la connexion
        connection = ConnectionMultiplexer.Connect(ConnectionString);
        // Récupérer la base de données par défaut numéro 0
        db = connection.GetDatabase();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        // Méthode Set : écrire dans le cache (clé, valeur, expiration en secondes)
        bool res = Set(this.textBox1.Text, this.textBox2.Text, 1000);
        if (res)
        {
            MessageBox.Show("Opération réussie");
        }
        else
        {
            MessageBox.Show("Échec de l'opération");
        }
    }

    /// <summary>
    /// Enregistrement clé‑valeur chaîne Redis (wrapper simplifié)
    /// </summary>
    bool Set(string key, object data, int cacheTime)
    {
        if (string.IsNullOrEmpty(key)) return false;
        // Définir le délai d'expiration
        var expire = TimeSpan.FromSeconds(cacheTime);
        return db.StringSet(key, data.ToString(), expire);
    }
}

Se connecter à Redis

Ouvrez Visual Studio, créez un projet WinForms puis installez les paquets de dépendance via NuGet

Installer les dépendances

1. StackExchange.Redis
   Le client open‑source Redis le plus répandu de l’écosystème .NET pour communiquer avec le serveur Redis.
   Dépôt Github：https://github.com/StackExchange/StackExchange/StackExchange.Redis
   Redis utilise le protocole TCP. Théoriquement on pourrait écrire des sockets bruts, mais les bibliothèques tierces éprouvées sont utilisées en production.
2. Newtonsoft.Json（Json.NET）
   Gère la sérialisation : transforme des objets en chaînes JSON puis en tableaux d’octets pour Redis ; désérialise à la lecture.
   À installer depuis NuGet. La méthode JsonConvert.SerializeObject provient de cette bibliothèque.

Méthodes du wrapper Redis

// Écrire dans le cache : stocker un objet avec expiration en minutes
private bool Set(string key, object data, int cacheTime)
{
    if (data == null)
    {
        return false;
    }
    var entryBytes = Serialize(data);
    var expiresIn = TimeSpan.FromMinutes(cacheTime);
    return db.StringSet(key, entryBytes, expiresIn);
}

// Sérialisation objet : entité → tableau d’octets UTF8
private byte[] Serialize(object data)
{
    var json = JsonConvert.SerializeObject(data);
    return Encoding.UTF8.GetBytes(json);
}

Démonstration Redis avec WinForms

Liens de téléchargement

À l’heure actuelle (2026), Redis officiel ne fournit que des paquets pour Linux. La version Windows est archivée et maintenue par Microsoft, sans nouvelle mise à jour.

1. Site officiel (version Linux) : http://redis.io/download
2. Dépôt Github pour Windows : https://github.com/MSOpenTech/redis/tags
3. Version exemple (win‑3.2.100) :
   https://github.com/MicrosoftArchive/redis/releases/tag/win-3.2.100

Fichiers clés après extraction

Lancer le serveur Redis depuis CMD

1. Ouvrez CMD et allez dans le dossier où vous avez extrait Redis

cd D:\Redis\Redis-x64-3.2.100

2. Commande de lancement (charge le fichier de configuration)

redis-server redis.windows.conf

Indicateurs de démarrage réussi :

• Mode d’exécution : Running in standalone mode (mode autonome)
• Port par défaut : 6379

Inconvénient : avec cette méthode, fermer la fenêtre CMD arrête immédiatement le service Redis

Installer Redis comme service système Windows

Un lancement simple via CMD ne permet pas de fonctionner en arrière‑plan. L’installation en service système autorise le démarrage automatique au démarrage de Windows.

Nous utilisons seulement un lancement temporaire pour la démonstration du cours, cette étape est donnée à titre indicatif.

Connexion Redis et test des commandes basiques

1. Commande de connexion client

Ouvrez une nouvelle fenêtre CMD, allez dans le dossier Redis et exécutez :

redis-cli.exe -h 127.0.0.1 -p 6379

• -h : indique l’adresse IP du serveur Redis (vous pouvez renseigner une IP du réseau local pour une connexion distante)
• -p : indique le numéro de port

2. Démonstration des commandes de base

# Définir une paire clé‑valeur
set key1 value1
# Récupérer la valeur d’une clé
get key1

# La requête sur une clé inexistante renvoie (nil)
get kkkk

set ddd 123
get ddd

Règles :

• set attend à la fois le paramètre【key】et【value】, une absence de paramètres provoque une erreur
• Interroger une clé qui n’existe pas renvoie (nil)

Remarques

1. Redis 3.2 pour Windows est très ancien. Évitez d’utiliser la version Windows en environnement de production, préférez un déploiement sous Linux ;
2. Pour les connexions distantes, adaptez le pare‑feu et modifiez le fichier de configuration pour autoriser les accès depuis des IP externes ;
3. La fenêtre CMD du serveur doit rester ouverte pour que les clients puissent se connecter.

Installation

Définition de base de Redis

Redis est un logiciel open‑source écrit en ANSI C, un système de stockage / base de données clé‑valeur accessible sur le réseau, fonctionnant en mémoire et avec persistance des données. Il propose des API client pour de multiples langages de programmation.

1. Il appartient aux bases de données NoSQL non relationnelles ;
2. Il appartient à la même famille que Memcached, mais il est plus complet et comble beaucoup de ses limites ;
3. Il est souvent utilisé comme solution de cache complémentaire aux bases relationnelles comme MySQL.

Types de données pris en charge

• String : type chaîne de caractères
• List : liste doublement chaînée
• Set : collection non ordonnée
• zset(sorted set) : collection triée
• Hash : structure de hachage (semblable à Map)

Memcached ne gère que le type chaîne, c’est l’une des différences les plus marquantes entre les deux outils.

Fonctionnalités

1. Prise en charge multi‑langages
   Les SDK officiels existent pour Java, C/C++, C#, PHP, JavaScript, Python, Ruby, Perl et bien d’autres langages pour une intégration facile.
2. Synchronisation maître‑esclave
   La réplication maître‑esclave permet les sauvegardes distantes et la séparation lecture‑écriture pour améliorer la disponibilité.
3. Haute performance
   Les données résident principalement en mémoire, les lectures et écritures sont très rapides, il est largement utilisé comme cache distribué.
4. Persistance des données
   Les données en mémoire peuvent être enregistrées sur disque, elles ne sont pas totalement perdues au redémarrage (Memcached n’a pas de persistance par défaut).

Contexte

Au début, le projet Redis était financé, développé et maintenu par VMware.

Nous allons illustrer l’usage de Redis avec un exemple simple de client Redis WinForm(C#), un programme d’introduction montrant comment connecter C# à Redis.

• Définir des couples clé‑valeur
• Récupérer une valeur à partir d’une clé
  

Comparaison rapide Redis vs Memcached

Présentation