1. Underlying call: IDatabase.StringSet() to write Redis string‑type data
2. Serialization logic: arbitrary object → JSON string → UTF8 byte array stored into Redis
3. Deserialization logic: read byte array → JSON string → target generic object
4. Return value: true = success, false = failure

Required namespaces

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

The example below uses Set, accepts a key, byte array, and expiration duration.

/// <summary>
/// Write cache entry to Redis
/// </summary>
/// <param name="key">Cache key</param>
/// <param name="data">Any object instance</param>
/// <param name="cacheTime">Expiration time 【minutes】</param>
/// <returns>true for success / false for failure</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>
/// Object serialization: object → byte[]
/// </summary>
private byte[] Serialize(object data)
{
    string json = JsonConvert.SerializeObject(data);
    return Encoding.UTF8.GetBytes(json);
}

/// <summary>
/// Read cached value by key
/// </summary>
/// <typeparam name="T">Target object type</typeparam>
/// <param name="key">Cache key</param>
/// <returns>default(T) if key does not exist</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>
/// Deserialization: byte[] → T object
/// </summary>
private T Deserialize<T>(byte[] serializedObject)
{
    if (serializedObject == null)
    {
        return default(T);
    }
    string json = Encoding.UTF8.GetString(serializedObject);
    return JsonConvert.DeserializeObject<T>(json);
}

Notes

1. Time unit
   In code TimeSpan.FromMinutes(cacheTime) means input value represents 【minutes】
   If you call Set(key,val,1000) from your form, cache will expire after 1000 minutes, NOT seconds!

The earlier WinForms sample used hard‑coded 1000, this is a common pitfall.
If you need to pass seconds, replace with TimeSpan.FromSeconds(cacheTime)

2. Dependencies installation
   Install both NuGet packages:

• StackExchange.Redis
• Newtonsoft.Json

2. Data storage format
   All objects are serialized to JSON binary and stored inside Redis; values viewed in Redis client are standard JSON text.
3. RedisValue compatibility
   db.StringGet(key) returns RedisValue, it supports implicit conversion to byte[] and can be passed directly into Deserialize<T>.
4. Thread‑safety suggestion
   IConnectionMultiplexer should be global singleton. Do not create new connection on every Redis read‑write.

Usage example

// Write entry (expire after 30 minutes)
bool ok = Set("user:1001", new {Id = 1001, Name = "test"}, 30);

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

// Read model entity example
// var model = Get<UserInfo>("user:1001");

Recommendations

Extract these helper methods together with Redis connection logic into a standalone static helper class RedisHelper.cs. Avoid putting them inside Form code for better separation‑of‑concerns.

Write value

After you install Redis, it runs as an independent background service. To access it from C# WinForms, you establish a connection much like connecting to a regular database.

The connection‑string configuration shown below is placed inside App.config

1. App.config Configuration

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <connectionStrings>
    <!-- Redis connection string -->
    <add name="RedisConnectionString" connectionString="127.0.0.1:6379"/>
    <!-- Short form: connectionString="localhost" uses default port 6379 -->
  </connectionStrings>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>
</configuration>

Connection string explanation

• localhost / 127.0.0.1：Local Redis service
• Default port 6379；Format for non‑default port：127.0.0.1:6380
• If Redis is password‑protected：127.0.0.1:6379,password=yourpassword

2. Core Code in Form1.cs

Required NuGet package

StackExchange.Redis

Required namespaces

using StackExchange.Redis;
using System.Configuration;

public partial class Form1 : Form
{
    // Redis database operation object
    private IDatabase db;
    // Read connection string from config file
    private string ConnectionString = ConfigurationManager.ConnectionStrings["RedisConnectionString"].ConnectionString;
    // Multiplexed connection (official recommended singleton, volatile for thread‑safety)
    private volatile IConnectionMultiplexer connection;

    public Form1()
    {
        InitializeComponent();
        // Establish connection
        connection = ConnectionMultiplexer.Connect(ConnectionString);
        // Get default database No.0
        db = connection.GetDatabase();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        // Set method: write cache (key, value, expiration seconds)
        bool res = Set(this.textBox1.Text, this.textBox2.Text, 1000);
        if (res)
        {
            MessageBox.Show("Set succeeded");
        }
        else
        {
            MessageBox.Show("Set failed");
        }
    }

    /// <summary>
    /// Simple wrapper for writing Redis string key‑value pairs
    /// </summary>
    bool Set(string key, object data, int cacheTime)
    {
        if (string.IsNullOrEmpty(key)) return false;
        // Set expiration time
        var expire = TimeSpan.FromSeconds(cacheTime);
        return db.StringSet(key, data.ToString(), expire);
    }
}

Connect to Redis

Open Visual Studio, create a WinForms project, then install dependency packages via NuGet

Install Dependencies

1. StackExchange.Redis
   The most‑popular open‑source Redis client in the .NET ecosystem for communicating with Redis server.
   Github Repository：https://github.com/StackExchange/StackExchange/StackExchange.Redis
   Redis exposes TCP protocol. In theory you could write raw Socket code, but mature third‑party libraries are almost always used in production development.
2. Newtonsoft.Json（Json.NET）
   Handles object serialization: converts arbitrary objects into JSON strings then byte arrays for Redis storage; deserializes data on readback.
   Must be installed from NuGet. The code JsonConvert.SerializeObject comes from this library.

Redis Wrapper Methods

// Write cache: store object with expiration in 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);
}

// Object serialization: entity object → UTF8 byte array
private byte[] Serialize(object data)
{
    var json = JsonConvert.SerializeObject(data);
    return Encoding.UTF8.GetBytes(json);
}

Demonstrate Redis with WinForms

Download Links

Currently (2026), the official Redis project only provides installation packages for Linux. The Windows port is archived and maintained by Microsoft (no further updates).

1. Official site (Linux version): http://redis.io/download
2. Windows‑version Github repository: https://github.com/MSOpenTech/redis/tags
3. Sample release (win‑3.2.100):
   https://github.com/MicrosoftArchive/redis/releases/tag/win-3.2.100

Core Files After Extraction

Start Redis Server via CMD

1. Open CMD and change directory to your extracted Redis folder

cd D:\Redis\Redis-x64-3.2.100

2. Start command (loads configuration file)

redis-server redis.windows.conf

Signs of successful startup:

• Running mode: Running in standalone mode
• Default port: 6379

Drawback: When you start this way, closing the CMD window will stop the Redis service immediately

Install as Windows System Service

Starting from ordinary CMD cannot run in background. You can install Redis as a system service to enable auto‑start on boot.

We only use temporary startup for course demonstration; this step is for reference only.

Redis Connection and Basic Command Test

1. Client connection command

Open a new CMD window, go to Redis directory and run:

redis-cli.exe -h 127.0.0.1 -p 6379

• -h: Specify Redis server IP (you can fill in LAN IP of other machines for remote connection)
• -p: Specify port number

2. Basic command demo

# Set key‑value pair
set key1 value1
# Get value by key
get key1

# Query non‑existent key returns (nil)
get kkkk

set ddd 123
get ddd

Rules:

• set requires both【key】and【value】parameters. Missing parameters will trigger an error
• Querying a non‑existing key returns (nil)

Notes

1. Windows Redis 3.2 is very old. Do not use Windows‑based Redis in production. Deployment on Linux is recommended;
2. To connect remotely, you need to adjust firewall settings and modify config file to allow access from external IP addresses;
3. The server‑side CMD window must stay open for clients to connect normally.

Installation

Redis Basic Definition

Redis is an open‑source software written in ANSI C, network‑accessible key‑value database / storage system that supports in‑memory storage and data persistence. It provides client APIs for multiple programming languages.

1. It belongs to NoSQL non‑relational databases;
2. Similar to Memcached but with richer features, it makes up for many shortcomings of Memcached;
3. Commonly used as a supplementary caching solution for relational databases such as MySQL.

Supported Data Types

• String: String type
• List: Doubly‑linked list
• Set: Unordered collection
• zset(sorted set): Sorted collection
• Hash: Hash structure (similar to Map)

Memcached only supports string type, which is one of the most typical differences between them.

Features

1. Multi‑language client support
   Official SDKs are available for Java, C/C++, C#, PHP, JavaScript, Python, Ruby, Perl and many other languages for easy integration.
2. Master‑slave synchronization
   Supports master‑slave replication for off‑site data backup and read‑write separation to improve service availability.
3. High performance
   Data resides mainly in memory for extremely fast read and write performance, widely used as a distributed cache.
4. Data persistence
   In‑memory data can be persisted to disk so data will not be fully lost after restart (Memcached has no persistence by default).

Background

The early Redis project was funded, developed and maintained by VMware.

We will demonstrate Redis usage with a simple WinForm(C#) Redis client demo, an introductory sample showing how C# connects to Redis.

• Set key‑value pairs
• Get value by key
  

Brief comparison: Redis vs Memcached

Introduction