1. La llamada interna IDatabase.StringSet() escribe datos de tipo cadena en Redis
2. Lógica de serialización: objeto arbitrario → cadena JSON → arreglo de bytes UTF‑8 almacenado en Redis
3. Lógica de deserialización: lectura del arreglo de bytes → cadena JSON → objeto genérico destino
4. Valor devuelto: true = configuración exitosa, false = configuración fallida

Espacios de nombres requeridos

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

El siguiente ejemplo usa Set, recibe una clave, un arreglo de bytes y el tiempo de expiración.

/// <summary>
/// Escribir caché en Redis
/// </summary>
/// <param name="key">Clave de caché</param>
/// <param name="data">Cualquier objeto</param>
/// <param name="cacheTime">Duración de expiración 【minutos】</param>
/// <returns>true éxito / false fallo</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>
/// Serialización de objeto: object → byte[]
/// </summary>
private byte[] Serialize(object data)
{
    string json = JsonConvert.SerializeObject(data);
    return Encoding.UTF8.GetBytes(json);
}

/// <summary>
/// Leer caché por clave
/// </summary>
/// <typeparam name="T">Tipo objetivo</typeparam>
/// <param name="key">Clave de caché</param>
/// <returns>devuelve default(T) si el caché no existe</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>
/// Deserialización: byte[] → objeto 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);
}

Notas

1. Unidad de tiempo
   En el código TimeSpan.FromMinutes(cacheTime) significa el valor ingresado representa 【minutos】
   Si llamas desde un formulario con Set(key,val,1000), el caché expirará en 1000 minutos, no en segundos!

El código anterior del formulario usaba el valor 1000, es un error muy común.
Si necesitas usar segundos, cámbialo por TimeSpan.FromSeconds(cacheTime)

2. Instalación de dependencias
   Debes instalar ambos paquetes en NuGet:

• StackExchange.Redis
• Newtonsoft.Json

2. Formato de almacenamiento
   Todos los objetos se serializan a binario JSON y se guardan en Redis; lo que ves en el cliente Redis es texto JSON estándar.
3. Compatibilidad con RedisValue
db.StringGet(key) devuelve RedisValue, admite conversión implícita a byte[], por lo que se puede pasar directamente a Deserialize<T>.
4. Recomendación de seguridad para hilos
   IConnectionMultiplexer debe ser un singleton global, no crees una nueva conexión en cada lectura o escritura de Redis.

Ejemplo de uso

// Escribir (expira en 30 minutos)
bool ok = Set("user:1001", new {Id = 1001, Name = "test"}, 30);

// Leer
var user = Get<dynamic>("user:1001");

// Ejemplo de lectura de clase de entidad
// var model = Get<UserInfo>("user:1001");

Recomendaciones

Extrae estos métodos junto con el código de conexión Redis a una clase helper estática independiente RedisHelper.cs. No los dejes dentro del código del formulario Form para lograr un desacoplamiento de lógica de negocio.

Escribir valor

Después de instalar Redis, se ejecuta como un servicio independiente. Para usarlo desde C# WinForms debemos establecer una conexión, igual que con cualquier base de datos.

La cadena de conexión que se muestra a continuación se coloca dentro de app.config

1. Configuración en App.config

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <connectionStrings>
    <!-- Cadena de conexión Redis -->
    <add name="RedisConnectionString" connectionString="127.0.0.1:6379"/>
    <!-- Forma abreviada connectionString="localhost" puerto por defecto 6379 -->
  </connectionStrings>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>
</configuration>

Explicación de la cadena de conexión

• localhost / 127.0.0.1：Servicio Redis local
• Puerto por defecto 6379；Para otro puerto：127.0.0.1:6380
• Si Redis tiene contraseña：127.0.0.1:6379,password=tucontraseña

2. Código principal Form1.cs

Paquete NuGet necesario

StackExchange.Redis

Espacios de nombres que debes importar

using StackExchange.Redis;
using System.Configuration;

public partial class Form1 : Form
{
    // Objeto para operar la base de datos Redis
    private IDatabase db;
    // Leer cadena de conexión desde el archivo de configuración
    private string ConnectionString = ConfigurationManager.ConnectionStrings["RedisConnectionString"].ConnectionString;
    // Conexión multiplexada (singleton recomendado oficialmente, volatile para seguridad de hilos)
    private volatile IConnectionMultiplexer connection;

    public Form1()
    {
        InitializeComponent();
        // Establecer conexión
        connection = ConnectionMultiplexer.Connect(ConnectionString);
        // Obtener base de datos número 0 por defecto
        db = connection.GetDatabase();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        // Método Set: escribir caché (clave, valor, segundos de expiración)
        bool res = Set(this.textBox1.Text, this.textBox2.Text, 1000);
        if (res)
        {
            MessageBox.Show("Guardado correctamente");
        }
        else
        {
            MessageBox.Show("Error al guardar");
        }
    }

    /// <summary>
    /// Guardar par clave‑valor de texto en Redis (wrapper simple)
    /// </summary>
    bool Set(string key, object data, int cacheTime)
    {
        if (string.IsNullOrEmpty(key)) return false;
        // Definir tiempo de expiración
        var expire = TimeSpan.FromSeconds(cacheTime);
        return db.StringSet(key, data.ToString(), expire);
    }
}

Conectarse a Redis

Abre Visual Studio, crea un proyecto WinForms e instala los paquetes de dependencia mediante NuGet

Instalar dependencias

1. StackExchange.Redis
   El cliente open‑source para Redis más usado en el ecosistema .NET, se encarga de la comunicación con el servidor Redis.
   Repositorio Github：https://github.com/StackExchange/StackExchange/StackExchange.Redis
   Redis trabaja sobre protocolo TCP. Teóricamente se podrían escribir sockets manuales, pero en desarrollo productivo se usan librerías de terceros consolidadas.
2. Newtonsoft.Json（Json.NET）
   Realiza la serialización de objetos: convierte objetos a cadenas JSON y matrices de bytes para guardar en Redis; hace la deserialización al leer.
   Hay que instalarlo por NuGet. El código JsonConvert.SerializeObject pertenece a esta librería.

Métodos del wrapper Redis

// Escribir caché: guardar objeto, definir caducidad en minutos
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);
}

// Serialización de objeto: entidad → matriz de bytes UTF8
private byte[] Serialize(object data)
{
    var json = JsonConvert.SerializeObject(data);
    return Encoding.UTF8.GetBytes(json);
}

Ejemplo práctico de Redis con WinForms

Enlaces de descarga

Actualmente (2026), el proyecto oficial de Redis solo ofrece paquetes de instalación para Linux. La versión para Windows está archivada y mantenida por Microsoft, y ya no recibe actualizaciones.

1. Sitio oficial (versión Linux): http://redis.io/download
2. Repositorio Github de la versión Windows: https://github.com/MSOpenTech/redis/tags
3. Versión de ejemplo (win‑3.2.100):
   https://github.com/MicrosoftArchive/redis/releases/tag/win-3.2.100

Archivos principales después de descomprimir

Iniciar el servidor Redis desde CMD

1. Abre CMD y navega hasta la carpeta donde descomprimiste Redis

cd D:\Redis\Redis-x64-3.2.100

2. Comando de inicio (carga el archivo de configuración)

redis-server redis.windows.conf

Señales de arranque correcto:

• Modo de ejecución: Running in standalone mode (modo independiente)
• Puerto por defecto: 6379

Desventaja: al arrancar de esta forma, si cierras la ventana de CMD, el servicio Redis se detiene inmediatamente

Instalar como servicio del sistema Windows

El arranque normal desde CMD no se ejecuta en segundo plano. Puedes instalarlo como servicio para que se inicie automáticamente con el sistema.

Para la demostración del curso solo usamos un arranque temporal, este paso es solo de referencia.

Conexión a Redis y prueba de comandos básicos

1. Comando de conexión del cliente

Abre otra ventana de CMD, entra en la carpeta de Redis y ejecuta:

redis-cli.exe -h 127.0.0.1 -p 6379

• -h: especifica la IP del servidor Redis (puedes indicar la IP de otro equipo de la red local para conectarte de forma remota)
• -p: indica el número de puerto

2. Ejemplo de comandos básicos

# Establecer par clave‑valor
set key1 value1
# Obtener el valor asociado a una clave
get key1

# Al consultar una clave inexistente devuelve (nil)
get kkkk

set ddd 123
get ddd

Reglas:

• set requiere los dos parámetros【key】y【value】, si faltan parámetros se producirá un error
• Si consultas una clave que no existe, obtendrás (nil)

Observaciones

1. La versión Windows Redis 3.2 es muy antigua. En entornos de producción no se recomienda usar Redis para Windows, es mejor desplegarlo en Linux;
2. Para conexiones remotas debes configurar el firewall y modificar el archivo de configuración para permitir accesos desde IP externas;
3. La ventana CMD del servidor debe permanecer abierta para que los clientes puedan conectarse correctamente.

Instalación

Definición básica de Redis

Redis es un software de código abierto escrito en ANSI C, un sistema de almacenamiento / base de datos clave‑valor accesible por red, con almacenamiento en memoria y persistencia de datos. Ofrece APIs de cliente para múltiples lenguajes de programación.

1. Pertenece a las bases de datos NoSQL no relacionales;
2. Es similar a Memcached pero con más funcionalidades, cubriendo muchas de sus limitaciones;
3. Se usa frecuentemente como solución de caché complementaria para bases de datos relacionales como MySQL.

Tipos de datos admitidos

• String：Tipo cadena de texto
• List：Lista doblemente enlazada
• Set：Colección desordenada
• zset(sorted set)：Colección ordenada
• Hash：Estructura hash (similar a Map)

Memcached solo admite cadenas de texto, esta es una de las diferencias más representativas entre ambos.

Características

1. Soporte de clientes multi‑idioma
   Cuenta con SDK oficial para Java, C/C++, C#, PHP, JavaScript, Python, Ruby, Perl y muchos lenguajes más, facilitando la integración en desarrollos.
2. Sincronización maestro‑esclavo
   Admite replicación maestro‑esclavo para realizar copias de seguridad remotas y separación de lectura‑escritura, mejorando la disponibilidad del servicio.
3. Alto rendimiento
   Los datos residen principalmente en memoria, las lecturas y escrituras son muy veloces, se usa ampliamente como caché distribuido.
4. Capacidad de persistencia
   Los datos en memoria se pueden guardar en disco, no se pierden totalmente tras reiniciar (Memcached no tiene persistencia por defecto).

Contexto

El proyecto inicial de Redis fue financiado, desarrollado y mantenido por VMware.

Usaremos un ejemplo sencillo de cliente Redis en WinForm(C#) para mostrar su funcionamiento, es un programa introductorio que muestra la conexión desde C# hacia Redis.

• Establecer pares clave‑valor
• Obtener valor mediante clave
  

Comparación breve Redis vs Memcached

Introducción