C#对Redis 的操作

redis 的连接

public class RedisHelper
{
    string _ip = string.Empty;
    int _port = 0;
    string _password = string.Empty;
    public RedisHelper(string ip, int port, string password=null)
    {
        _ip = ip;
        _port = port;
        _password = password;
    }

    private ConnectionMultiplexer _redisConn;

    public ConnectionMultiplexer RedisConn
    {
        get
        {
            try
            {
                if (!IsConnected())
                {
                    ConfigurationOptions Configuration = new ConfigurationOptions
                    {
                        EndPoints = { $"{_ip}:{_port.ToString()}" },
                        Password = _password
                    };
                    _redisConn= ConnectionMultiplexer.Connect(Configuration);
                }
            }
            catch (Exception ex) 
            {
                throw ex;
            }
            return _redisConn;
        }
    }

    /// <summary>
    /// 获取redis的连接状态
    /// </summary>
    /// <returns></returns>
    public  bool IsConnected()
    {
        return _redisConn?.IsConnected ?? false;
    }
}

Redis存入数据库的选择

using (ConnectionMultiplexer conn = redis.RedisConn)
{
 // 获取数据库实例，这里选择 db4，共16个数据库，可以选择0~15任意一个
 var db = conn.GetDatabase(4);
}

Redis的5种数据类型的写入和读取

string类型

using (ConnectionMultiplexer conn = redis.RedisConn)
{
    string key = "test1";
    // 获取数据库实例，这里选择 db4
    var db = conn.GetDatabase(4);
    if (db.KeyExists(key))
    {
        db.KeyDelete(key);
    }
    db.StringSet(key, DateTime.Now.ToString());

    MessageBox.Show(db.StringGet(key));
}

HashSet 类型

using (ConnectionMultiplexer conn = redis.RedisConn)
{
    string key = "WHSUS_HashSet";
    var db = conn.GetDatabase(4);
    if (db.KeyExists(key))
    {
        db.KeyDelete(key);
    }
    for (int i = 0; i < 5; i++)
    {
        UserInfoDto userInfo = new UserInfoDto();
        userInfo.Id = i;
        userInfo.LastLoginTime = DateTime.Now;
        userInfo.Password = "1234789" + i;
        userInfo.StaffId = "7894" + i;
        userInfo.StaffName = "Test" + i;
        db.HashSet(key, userInfo.Id, JsonConvert.SerializeObject(userInfo));
    }
    RedisValue redisValue = db.HashGet(key, 4);
    UserInfoDto userInfo1 = new UserInfoDto();
    userInfo1 = JsonConvert.DeserializeObject<UserInfoDto>(redisValue);
    MessageBox.Show(userInfo1.StaffName);
}

Set 类型

using (ConnectionMultiplexer conn = redis.RedisConn)
{
    string keyPrefix = "WHSUS_Set";
    var db = conn.GetDatabase(4);
    for (int i = 0; i < 5; i++)
    {
        UserInfoDto userInfo = new UserInfoDto();
        userInfo.Id = i;
        userInfo.LastLoginTime = DateTime.Now;
        userInfo.Password = "1234789_" + i;
        userInfo.StaffId = "7894_" + i;
        userInfo.StaffName = "Test_" + i;
        db.KeyDelete(keyPrefix + userInfo.Id);
        db.SetAdd(keyPrefix + userInfo.Id + ":id", userInfo.StaffId);
        db.SetAdd(keyPrefix + userInfo.Id + ":name", userInfo.StaffName);
    }

    // exists  和 flag 都是false 
    bool exists = db.KeyExists($"WHSUS_Set2");
    bool flag= db.KeyDelete($"WHSUS_Set2");

    RedisValue[] redisValuesId = db.SetMembers($"{keyPrefix}2:id");
    RedisValue redisValueId = db.SetMembers($"{keyPrefix}2:id").FirstOrDefault();
    string name = redisValueId;

    #region 模糊匹配
    List<string> keys = new List<string>();
    var server = db.Multiplexer.GetServer(db.Multiplexer.GetEndPoints()[0]);
    foreach (var key in server.Keys(db.Database, $"{keyPrefix}0*"))
    {
        keys.Add(key);
    }
    foreach (var item in keys)
    {
        RedisValue value = db.SetMembers(item).FirstOrDefault();
        db.KeyDelete(item);
    }
    #endregion
}

List 类型

using (ConnectionMultiplexer conn = redis.RedisConn)
{
    if (redis.IsConnected())
    {
        string key = "WHSUS_ListTest";
        var db = conn.GetDatabase(4);
        if (db.KeyExists(key))
        {
            db.KeyDelete(key);
        }
        List<UserInfoDto> users = new List<UserInfoDto>();
        // 类似队列压入、取出
        for (int i = 0; i < 5; i++)
        {
            UserInfoDto userInfo = new UserInfoDto();
            userInfo.Id = i;
            userInfo.LastLoginTime = DateTime.Now;
            userInfo.Password = "1234789" + i;
            userInfo.StaffId = "7894" + i;
            userInfo.StaffName = "Test" + i;
            users.Add(userInfo);
            //db.ListLeftPush(key, $"test——{i}");
            db.ListLeftPush(key, $"{JsonConvert.SerializeObject(userInfo)}");
        }
        while (db.ListLength(key) != 0)
        {
            RedisValue redisValue = db.ListLeftPop(key);
        }

        //一次取出所有
        RedisValue[] redisValues = db.ListRange(key);
    }
}

两种取出所有值方法的对比

A：

while (db.ListLength(key) != 0)
        {
            RedisValue redisValue = db.ListLeftPop(key);
        }

优点

• 逐个处理元素：适用于需要逐个处理列表元素的情况，每次弹出一个处理，确保处理的元素不再 保留在列表中。
• 节省内存：一次只处理一个元素，适用于列表非常大且内存有限的情况，不会将整个列表加载到内存中。

缺点

• 多次网络往返：每次 ListLeftPop 都会与 Redis 服务器通信，对于长列表可能会产生较多的网络请求，导致性能开销。
• 可能阻塞：如果列表元素处理较慢，会阻塞循环，无法高效地批量处理元素。
  B:

 RedisValue[] redisValues = db.ListRange(key);

优点：

• 减少网络往返：一次性获取整个列表的所有元素，减少了与 Redis 服务器的通信次数，适用于需要快速获取整个列表内容的情况。
• 批量处理：可以一次性处理所有元素，适用于批量操作的场景，能够更高效地处理数据。

缺点：

• 高内存消耗：会将整个列表加载到内存中，适用于列表较小或内存充足的情况。如果列表非常大，可能导致内存溢出。
• 无删除操作：只是获取列表的副本，不会从 Redis 列表中删除元素，如果需要删除元素还需要额外的操作。

Sorted 类型

using (ConnectionMultiplexer conn = redis.RedisConn)
{
    string keyPrefix = "WHSUS_SortedTest";
    var db = conn.GetDatabase(4);
    if (db.KeyExists(keyPrefix))
    {
        db.KeyDelete(keyPrefix);
    }
    List<UserInfoDto> users = new List<UserInfoDto>();
    for (int i = 0; i < 5; i++)
    {
        UserInfoDto userInfo = new UserInfoDto();
        userInfo.Id = i;
        userInfo.LastLoginTime = DateTime.Now;
        userInfo.Password = "1234789" + i;
        userInfo.StaffId = "7894" + i;
        userInfo.StaffName = "Test" + i;
        users.Add(userInfo);
        db.KeyDelete(keyPrefix + userInfo.Id + ":StaffId");
        db.KeyDelete(keyPrefix + userInfo.Id + ":StaffName");
        db.SortedSetAdd(keyPrefix + userInfo.Id + ":StaffId", userInfo.StaffId, userInfo.Id);
        db.SortedSetAdd(keyPrefix + userInfo.Id + ":StaffName", userInfo.StaffName, userInfo.Id);
    }
        SortedSetEntry? sortedSetEntry = db.SortedSetPop((RedisKey)(keyPrefix + "2:StaffId"));
}