1. Interner Aufruf von IDatabase.StringSet() zum Speichern von Redis‑String‑Daten
2. Serialisierungslogik：beliebiges Objekt → JSON‑Zeichenkette → UTF8‑Byte‑Array in Redis ablegen
3. Deserialisierungslogik：Byte‑Array einlesen → JSON‑Zeichenkette → generisches Zielobjekt
4. Rückgabewert：true = erfolgreich，false = fehlgeschlagen

Benötigte Namespaces

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

Das folgende Beispiel nutzt Set mit Schlüssel, Byte‑Array und Ablaufzeit.

/// <summary>
/// Schreibt einen Eintrag in den Redis‑Cache
/// </summary>
/// <param name="key">Cache‑Schlüssel</param>
/// <param name="data">Beliebiges Objekt</param>
/// <param name="cacheTime">Ablaufzeit 【Minuten】</param>
/// <returns>true erfolgreich / false fehlgeschlagen</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>
/// Objekt‑Serialisierung: object → byte[]
/// </summary>
private byte[] Serialize(object data)
{
    string json = JsonConvert.SerializeObject(data);
    return Encoding.UTF8.GetBytes(json);
}

/// <summary>
/// Cache‑Eintrag über Schlüssel auslesen
/// </summary>
/// <typeparam name="T">Zieltyp</typeparam>
/// <param name="key">Cache‑Schlüssel</param>
/// <returns>Gibt default(T) zurück, falls der Schlüssel nicht existiert</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>
/// Deserialisierung: byte[] → T‑Objekt
/// </summary>
private T Deserialize<T>(byte[] serializedObject)
{
    if (serializedObject == null)
    {
        return default(T);
    }
    string json = Encoding.UTF8.GetString(serializedObject);
    return JsonConvert.DeserializeObject<T>(json);
}

Hinweise

1. Zeiteinheit
   Im Code bedeutet TimeSpan.FromMinutes(cacheTime) dass der Eingabewert in 【Minuten】 angegeben wird
   Wenn Sie im Formular Set(key,val,1000) aufrufen, läuft der Cache nach 1000 Minuten ab, nicht nach Sekunden!

Im vorherigen Formular‑Beispiel war fest 1000 hinterlegt – das ist eine häufige Fehlerquelle.
Wenn Sie Sekunden verwenden möchten, ersetzen Sie durch TimeSpan.FromSeconds(cacheTime)

2. Abhängigkeiten installieren
   Beide NuGet‑Pakete müssen installiert sein:

• StackExchange.Redis
• Newtonsoft.Json

2. Daten‑Speicherformat
   Alle Objekte werden in JSON‑Binärdaten umgewandelt und in Redis gespeichert. Im Redis‑Client sehen Sie normalen JSON‑Text.
3. RedisValue‑Kompatibilität
   db.StringGet(key) liefert RedisValue, es kann implizit nach byte[] konvertiert und direkt an Deserialize<T> übergeben werden.
4. Hinweis zur Thread‑Sicherheit
   IConnectionMultiplexer sollte als globales Singleton verwendet werden. Erstellen Sie nicht bei jedem Redis‑Lese‑/Schreibvorgang eine neue Verbindung.

Anwendungsbeispiel

// Schreiben (läuft nach 30 Minuten ab)
bool ok = Set("user:1001", new {Id = 1001, Name = "test"}, 30);

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

// Beispiel zum Einlesen einer Modell‑Klasse
// var model = Get<UserInfo>("user:1001");

Empfehlung

Lagern Sie diese Hilfsmethoden samt Redis‑Verbindungscode in einer separaten statischen Hilfsklasse RedisHelper.cs aus. Vermeiden Sie die Ablage im Formular‑Code, um eine saubere Trennung der Zuständigkeiten zu erreichen.

Wert schreiben

Nach der Installation läuft Redis als eigenständiger Dienst. Um es aus C# WinForms zu nutzen, stellen Sie eine Verbindung her, vergleichbar mit einer normalen Datenbankverbindung.

Die unten stehende Verbindungszeichenfolge wird in der Datei app.config hinterlegt

1. App.config‑Konfiguration

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <connectionStrings>
    <!-- Redis‑Verbindungszeichenfolge -->
    <add name="RedisConnectionString" connectionString="127.0.0.1:6379"/>
    <!-- Kurzschreibweise connectionString="localhost" Standardport 6379 -->
  </connectionStrings>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>
</configuration>

Erläuterung zur Verbindungszeichenfolge

• localhost / 127.0.0.1：Lokaler Redis‑Dienst
• Standardport 6379；Anderer Port: 127.0.0.1:6380
• Wenn Redis mit Passwort geschützt ist: 127.0.0.1:6379,password=IhrPasswort

2. Form1.cs‑Hauptcode

Benötigtes NuGet‑Paket

StackExchange.Redis

Benötigte Namespaces

using StackExchange.Redis;
using System.Configuration;

public partial class Form1 : Form
{
    // Redis‑Datenbank‑Arbeitsobjekt
    private IDatabase db;
    // Einlesen der Verbindungszeichenfolge aus Konfigurationsdatei
    private string ConnectionString = ConfigurationManager.ConnectionStrings["RedisConnectionString"].ConnectionString;
    // Multiplex‑Verbindung (offiziell empfohlenes Singleton, volatile für Thread‑Sicherheit)
    private volatile IConnectionMultiplexer connection;

    public Form1()
    {
        InitializeComponent();
        // Verbindung aufbauen
        connection = ConnectionMultiplexer.Connect(ConnectionString);
        // Standard‑Datenbank Nummer 0 holen
        db = connection.GetDatabase();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        // Set‑Methode: Cache schreiben (Schlüssel, Wert, Ablauf in Sekunden)
        bool res = Set(this.textBox1.Text, this.textBox2.Text, 1000);
        if (res)
        {
            MessageBox.Show("Speichern erfolgreich");
        }
        else
        {
            MessageBox.Show("Speichern fehlgeschlagen");
        }
    }

    /// <summary>
    /// Redis‑String‑Schlüssel‑Wert schreiben (einfacher Wrapper)
    /// </summary>
    bool Set(string key, object data, int cacheTime)
    {
        if (string.IsNullOrEmpty(key)) return false;
        // Ablaufzeit festlegen
        var expire = TimeSpan.FromSeconds(cacheTime);
        return db.StringSet(key, data.ToString(), expire);
    }
}

Mit Redis verbinden

Öffnen Sie Visual Studio, erstellen Sie ein WinForms‑Projekt und installieren Sie anschließend die Abhängigkeiten über NuGet

Abhängigkeiten installieren

1. StackExchange.Redis
   Die am weitesten verbreitete Open‑Source‑Redis‑Client‑Bibliothek im .NET‑Ökosystem zur Kommunikation mit dem Redis‑Server.
   Github‑Repository：https://github.com/StackExchange/StackExchange/StackExchange.Redis
   Redis nutzt das TCP‑Protokoll. Theoretisch lassen sich Sockets manuell schreiben, in der Praxis werden aber ausgereifte Drittbibliotheken verwendet.
2. Newtonsoft.Json（Json.NET）
   Dient der Objektserialisierung: Wandelt beliebige Objekte in JSON‑Strings und Byte‑Arrays für Redis um; deserialisiert beim Auslesen.
   Muss über NuGet installiert werden. Der Code JsonConvert.SerializeObject stammt aus dieser Bibliothek.

Redis‑Wrapper‑Methoden

// Cache schreiben: Objekt speichern, Ablaufzeit in Minuten festlegen
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);
}

// Objekt‑Serialisierung: Entitätsobjekt → UTF8‑Byte‑Array
private byte[] Serialize(object data)
{
    var json = JsonConvert.SerializeObject(data);
    return Encoding.UTF8.GetBytes(json);
}

Redis‑Beispiel mit WinForms

Download‑Links

Stand 2026 bietet das offizielle Redis‑Projekt nur Installationspakete für Linux an. Die Windows‑Portierung wird von Microsoft archiviert gepflegt und erhält keine weiteren Updates.

1. Offizielle Seite (Linux‑Version): http://redis.io/download
2. Windows‑GitHub‑Repository: https://github.com/MSOpenTech/redis/tags
3. Beispiel‑Release (win‑3.2.100):
   https://github.com/MicrosoftArchive/redis/releases/tag/win-3.2.100

Wichtige Dateien nach dem Entpacken

Redis‑Server über CMD starten

1. CMD öffnen und in den entpackten Redis‑Ordner wechseln

cd D:\Redis\Redis-x64-3.2.100

2. Start‑Befehl (lädt Konfigurationsdatei)

redis-server redis.windows.conf

Anzeichen für erfolgreichen Start:

• Betriebsmodus: Running in standalone mode (Einzelbetrieb‑Modus)
• Standard‑Port: 6379

Nachteil: Bei dieser Startmethode stoppt der Redis‑Dienst sofort, wenn Sie das CMD‑Fenster schließen.

Als Windows‑Systemdienst installieren

Ein einfacher Start über CMD läuft nicht im Hintergrund. Durch die Installation als Systemdienst lässt sich ein automatischer Start beim Systemboot aktivieren.

Für die Kurs‑Demo verwenden wir nur einen temporären Start, dieser Schritt dient nur als Referenz.

Redis‑Verbindung und Test von Basis‑Befehlen

1. Client‑Verbindungsbefehl

Öffnen Sie ein neues CMD‑Fenster, wechseln Sie in den Redis‑Ordner und führen Sie aus:

redis-cli.exe -h 127.0.0.1 -p 6379

• -h: Legt die IP‑Adresse des Redis‑Servers fest (LAN‑IP anderer Rechner für Remote‑Zugriff möglich)
• -p: Legt die Port‑Nummer fest

2. Demo grundlegender Befehle

# Schlüssel‑Wert‑Paar setzen
set key1 value1
# Wert über Schlüssel abfragen
get key1

# Abfrage nicht vorhandener Schlüssel gibt (nil) zurück
get kkkk

set ddd 123
get ddd

Regeln:

• set benötigt sowohl【key】als auch【value】als Parameter, fehlende Parameter lösen einen Fehler aus
• Die Abfrage eines nicht vorhandenen Schlüssels gibt (nil) zurück

Hinweise

1. Windows Redis 3.2 ist sehr alt. Verwenden Sie die Windows‑Version nicht im Produktivbetrieb, ein Einsatz unter Linux wird empfohlen;
2. Für Remote‑Zugriffe müssen Firewall‑Einstellungen angepasst und die Konfigurationsdatei bearbeitet werden, um Zugriffe externer IP‑Adressen zu erlauben;
3. Das serverseitige CMD‑Fenster muss geöffnet bleiben, damit Clients sich verbinden können.

Installation

Redis Grunddefinition

Redis ist ein Open‑Source‑System, geschrieben in ANSI‑C, ein netzwerkfähiges Key‑Value‑Datenbanksystem mit Arbeitsspeicher‑Speicherung und Datenpersistenz. Es bietet Client‑APIs für zahlreiche Programmiersprachen.

1. Es zählt zu den NoSQL‑nicht‑relationalen Datenbanken;
2. Es ist verwandt mit Memcached, bietet aber mehr Funktionen und behebt dessen Schwächen;
3. Häufig eingesetzt als ergänzende Cache‑Lösung für relationale Datenbanken wie MySQL.

Unterstützte Datentypen

• String：Zeichenkettentyp
• List：Doppelt verkettete Liste
• Set：Ungeordnete Sammlung
• zset(sorted set)：Sortierte Sammlung
• Hash：Hash‑Struktur (ähnlich wie Map)

Memcached unterstützt nur Zeichenketten, das ist einer der wichtigsten Unterschiede beider Systeme.

Eigenschaften

1. Mehrsprachen‑Client‑Unterstützung
   Offizielle SDKs für Java, C/C++, C#, PHP, JavaScript, Python, Ruby, Perl und weitere Sprachen sorgen für eine einfache Integration in Projekte.
2. Master‑Slave‑Synchronisation
   Master‑Slave‑Replikation ermöglicht standortferne Backups und Lese‑Schreib‑Trennung zur Erhöhung der Verfügbarkeit.
3. Hohe Leistung
   Daten liegen primär im Arbeitsspeicher, Lese‑ und Schreibzugriffe sind extrem schnell, es wird oft als verteilter Cache verwendet.
4. Persistenz‑Fähigkeit
   Arbeitsspeicher‑Daten können auf Festplatte gespeichert werden, sodass nach Neustart nicht alle Daten verloren gehen (Memcached hat standardmäßig keine Persistenz).

Hintergrund

Das frühe Redis‑Projekt wurde von VMware gefördert, entwickelt und gepflegt.

Zur Demonstration verwenden wir ein einfaches WinForm(C#) Redis‑Client‑Demo, ein Einsteigerbeispiel für die C#‑Anbindung an Redis.

• Schlüssel‑Wert‑Paare setzen
• Wert per Schlüssel abfragen
  

Kurzer Vergleich Redis vs Memcached

Einführung