Redis 캐시와 C# 연동하기: 성능 최적화의 핵심 🚀

# 문자열 관련
SET key value         # 키에 값을 설정
GET key               # 키의 값을 가져옴
DEL key               # 키를 삭제

# 해시 관련
HSET key field value  # 해시의 필드에 값을 설정
HGET key field        # 해시의 필드 값을 가져옴
HGETALL key           # 해시의 모든 필드-값 쌍을 가져옴

# 리스트 관련
LPUSH key value       # 리스트의 왼쪽(앞)에 값을 추가
RPUSH key value       # 리스트의 오른쪽(뒤)에 값을 추가
LRANGE key start stop # 리스트의 특정 범위 요소를 가져옴

# 셋 관련
SADD key member       # 셋에 멤버를 추가
SMEMBERS key          # 셋의 모든 멤버를 가져옴

# 정렬된 셋 관련
ZADD key score member # 정렬된 셋에 점수와 멤버를 추가
ZRANGE key start stop # 정렬된 셋의 특정 범위 멤버를 가져옴

# 기타
EXPIRE key seconds    # 키에 만료 시간을 설정
TTL key               # 키의 남은 만료 시간을 확인

Install-Package StackExchange.Redis

using StackExchange.Redis;

public class RedisConnection
{
    private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
    {
        return ConnectionMultiplexer.Connect("localhost:6379");
    });

    public static ConnectionMultiplexer Connection => lazyConnection.Value;

    public static IDatabase RedisDb => Connection.GetDatabase();
}

var options = new ConfigurationOptions
{
    EndPoints = { "server1:6379", "server2:6379" },
    Password = "your_password",
    AllowAdmin = true,
    AbortOnConnectFail = false,
    ConnectTimeout = 5000,
    SyncTimeout = 5000
};

ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(options);

public static bool TestConnection()
{
    try
    {
        var db = RedisConnection.RedisDb;
        db.StringSet("test_key", "Hello, Redis!");
        var value = db.StringGet("test_key");
        return value == "Hello, Redis!";
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Redis connection test failed: {ex.Message}");
        return false;
    }
}

public class RedisStringExample
{
    private readonly IDatabase _db;

    public RedisStringExample(IDatabase db)
    {
        _db = db;
    }

    public void SetSimpleKeyValue(string key, string value)
    {
        _db.StringSet(key, value);
    }

    public string GetValue(string key)
    {
        return _db.StringGet(key);
    }

    public long IncrementCounter(string key)
    {
        return _db.StringIncrement(key);
    }

    public bool SetWithExpiry(string key, string value, TimeSpan expiry)
    {
        return _db.StringSet(key, value, expiry);
    }
}

public class RedisHashExample
{
    private readonly IDatabase _db;

    public RedisHashExample(IDatabase db)
    {
        _db = db;
    }

    public void SetUserProfile(string userId, Dictionary<string, string> profile)
    {
        var hashEntries = profile.Select(kv => new HashEntry(kv.Key, kv.Value));
        _db.HashSet($"user:{userId}", hashEntries.ToArray());
    }

    public Dictionary<string, string> GetUserProfile(string userId)
    {
        var hashEntries = _db.HashGetAll($"user:{userId}");
        return hashEntries.ToDictionary(
            he => he.Name.ToString(),
            he => he.Value.ToString());
    }

    public string GetUserField(string userId, string field)
    {
        return _db.HashGet($"user:{userId}", field);
    }

    public bool UpdateUserFiel  d(string userId, string field, string value)
    {
        return _db.HashSet($"user:{userId}", field, value);
    }
}

public class RedisListExample
{
    private readonly IDatabase _db;

    public RedisListExample(IDatabase db)
    {
        _db = db;
    }

    public void AddToRecentActivity(string userId, string activity)
    {
        _db.ListLeftPush($"recent_activity:{userId}", activity);
        _db.ListTrim($"recent_activity:{userId}", 0, 9); // 최근 10개 활동만 유지
    }

    public List<string> GetRecentActivities(string userId)
    {
        var activities = _db.ListRange($"recent_activity:{userId}", 0, -1);
        return activities.ToStringArray().ToList();
    }

    public string GetNextMessage(string queueName)
    {
        return _db.ListRightPop(queueName);
    }

    public void AddMessage(string queueName, string message)
    {
        _db.ListLeftPush(queueName, message);
    }
}

public class RedisSetExample
{
    private readonly IDatabase _db;

    public RedisSetExample(IDatabase db)
    {
        _db = db;
    }

    public void AddTag(string itemId, string tag)
    {
        _db.SetAdd($"item_tags:{itemId}", tag);
    }

    public List<string> GetTags(string itemId)
    {
        var tags = _db.SetMembers($"item_tags:{itemId}");
        return tags.ToStringArray().ToList();
    }

    public void AddUserToSkillGroup(string skill, string userId)
    {
        _db.SetAdd($"skill:{skill}", userId);
    }

    public List<string> GetUsersWithSkill(string skill)
    {
        var users = _db.SetMembers($"skill:{skill}");
        return users.ToStringArray().ToList();
    }

    public List<string> GetCommonSkills(string userId1, string userId2)
    {
        var commonSkills = _db.SetIntersect($"user_skills:{userId1}", $"user_skills:{userId2}");
        return commonSkills.ToStringArray().ToList();
    }
}

public class RedisSortedSetExample
{
    private readonly IDatabase _db;

    public RedisSortedSetExample(IDatabase db)
    {
        _db = db;
    }

    public void AddScore(string leaderboardId, string userId, double score)
    {
        _db.SortedSetAdd(leaderboardId, userId, score);
    }

    public List<string> GetTopScores(string leaderboardId, int count)
    {
        var scores = _db.SortedSetRangeByRankWithScores(leaderboardId, 0, count - 1, Order.Descending);
        return scores.Select(s => $"{s.Element}: {s.Score}").ToList();
    }

    public long GetUserRank(string leaderboardId, string userId)
    {
        return _db.SortedSetRank(leaderboardId, userId, Order.Descending) ?? -1;
    }

    public void AddTaskToQueue(string queueName, string task, double priority)
    {
        _db.SortedSetAdd(queueName, task, priority);
    }

    public string GetNextTask(string queueName)
    {
        var highestPriorityTask = _db.SortedSetPopMin(queueName);
        return highestPriorityTask.HasValue ? highestPriorityTask.Value.Element : null;
    }
}

public class RedisTransactionExample
{
    private readonly IDatabase _db;

    public RedisTransactionExample(IDatabase db)
    {
        _db = db;
    }

    public bool TransferPoints(string fromUser, string toUser, int points)
    {
        var tran = _db.CreateTransaction();

        tran.AddCondition(Condition.StringEqual($"user:{fromUser}:points", points.ToString()));

        tran.StringDecrementAsync($"user:{fromUser}:points", points);
        tran.StringIncrementAsync($"user:{toUser}:points", points);

        return tran.Execute();
    }

    public void AtomicListOperation(string listKey)
    {
        var tran = _db.CreateTransaction();

        tran.ListRightPopAsync(listKey);
        tran.ListLeftPushAsync(listKey, "new item");

        tran.Execute();
    }
}

public class RedisPipelineExample
{
    private readonly IDatabase _db;

    public RedisPipelineExample(IDatabase db)
    {
        _db = db;
    }

    public async Task BulkInsert(Dictionary<string, string> data)
    {
        var batch = _db.CreateBatch();

        var tasks = new List<Task>();
        foreach (var kvp in data)
        {
            tasks.Add(batch.StringSetAsync(kvp.Key, kvp.Value));
        }

        batch.Execute();
        await Task.WhenAll(tasks);
    }

    public async Task<List<string>> BulkGet(List<string> keys)
    {
        var batch = _db.CreateBatch();

        var tasks = keys.Select(key => batch.StringGetAsync(key)).ToList();

        batch.Execute();

        var results = await Task.WhenAll(tasks);
        return results.Select(r => r.ToString()).ToList();
    }
}