Redis：使用

安装 StackExchange.Redis

在 NuGet 中搜索 StackExchange.Redis 和 Newtonsoft.Json，直接点击按钮安装即可。

StackExchange.Redis 是 C# 操作 Redis 数据库的客户端。

Newtonsoft.Json 用来序列化 Josn 字符串及反序列化拿到对象。

Redis 数据类型

Redis 支持多种数据类型，如字符串（String）、哈希（Hash）、列表（List）、集合（Set）、有序集合（Sorted Set）等。

1.字符串（String）

特点：字符串是 Redis 中最基本的数据类型，它可以存储二进制数据、文本、JSON 数据等，一个键对应一个值，最大能存储 512MB 的数据。

适用场景

• 缓存：将经常访问的数据，如网页片段、数据库查询结果等存储在 Redis 字符串中。例如，在一个新闻网站中，将新闻内容以字符串形式缓存，当用户访问新闻页面时，优先从 Redis 中获取数据，减少数据库的访问压力，提高响应速度。

python

import redis

r = redis.Redis(host='localhost', port=6379, db=0)
# 设置新闻缓存
news_content = "这是一条重要新闻的内容"
r.set('news:1', news_content)
# 获取新闻缓存
print(r.get('news:1'))

• 计数器：利用 Redis 字符串的原子性操作（如 INCR、DECR）实现计数器功能。例如，统计文章的阅读量、网站的访问量等。

# 文章阅读量加 1
r.incr('article:1:views')
# 获取文章阅读量
views = r.get('article:1:views')
print(views)

• 分布式锁：通过 SETNX（SET if Not eXists）命令实现分布式锁。当多个进程或服务需要对共享资源进行互斥访问时，可以使用 Redis 字符串作为锁。

# 尝试获取锁
lock_acquired = r.setnx('resource:lock', 'locked')
if lock_acquired:
    try:
        # 执行需要加锁的操作
        print("获取锁成功，执行操作")
    finally:
        # 释放锁
        r.delete('resource:lock')
else:
    print("获取锁失败")

2.哈希（Hash）

特点：哈希类型是一个键值对的集合，类似于 Python 中的字典。适合存储对象，每个哈希可以存储多达 2³² - 1 个键值对。

适用场景

• 存储对象：将对象的各个属性存储在哈希中，方便对对象的属性进行单独操作。例如，在一个电商系统中，将用户信息存储在哈希中。

 

# 存储用户信息
user_info = {
    'name': 'John',
    'age': 30,
    'email': 'john@example.com'
}
r.hmset('user:1', user_info)
# 获取用户信息
print(r.hgetall('user:1'))

• 缓存对象：与存储对象类似，当需要缓存对象时，使用哈希类型可以避免序列化和反序列化的开销。

3.列表（List）

特点：列表是一个双向链表，元素可以从列表的两端进行插入和删除操作，插入和删除操作的时间复杂度为 O (1)。

适用场景

• 消息队列：利用列表的 LPUSH 和 RPOP 或 RPUSH 和 LPOP 操作实现简单的消息队列。生产者将消息插入到列表的一端，消费者从列表的另一端取出消息进行处理。

 

# 生产者发送消息
r.lpush('message_queue', 'message1')
r.lpush('message_queue', 'message2')
# 消费者接收消息
message = r.rpop('message_queue')
print(message)

• 最新消息列表：例如，在社交网站中，使用列表存储用户的最新动态，每次有新动态时，将其插入到列表头部。

# 发布新动态
r.lpush('user:1:feed', '用户发布了一条新动态')
# 获取最新的 10 条动态
latest_feeds = r.lrange('user:1:feed', 0, 9)
print(latest_feeds)

4.集合（Set）

特点：集合是无序且唯一的数据结构，支持交集、并集、差集等操作。

适用场景

• 去重：当需要对数据进行去重处理时，可以使用集合。例如，在统计网站的独立访客数时，将每个访客的 ID 存储在集合中。

# 记录访客 ID
r.sadd('visitors', 'user1')
r.sadd('visitors', 'user2')
r.sadd('visitors', 'user1')  # 重复的 ID 不会被添加
# 获取独立访客数
visitor_count = r.scard('visitors')
print(visitor_count)

• 社交关系：例如，在社交网络中，使用集合存储用户的好友列表，通过集合的交集、并集、差集操作可以方便地实现共同好友、推荐好友等功能。

 

# 用户 1 的好友列表
r.sadd('user:1:friends', 'user2', 'user3')
# 用户 2 的好友列表
r.sadd('user:2:friends', 'user1', 'user3')
# 计算共同好友
common_friends = r.sinter('user:1:friends', 'user:2:friends')
print(common_friends)

5.有序集合（Sorted Set）

特点：有序集合是在集合的基础上，为每个元素关联一个分数（score），元素按照分数从小到大排序。分数可以相同，当分数相同时，按照元素的字典序排序。

适用场景

• 排行榜：例如，在游戏中，使用有序集合存储玩家的分数，分数作为元素的排序依据，可以方便地实现排行榜功能。

# 记录玩家分数
r.zadd('game_rank', {'player1': 100, 'player2': 200, 'player3': 150})
# 获取排行榜前 3 名
top_players = r.zrevrange('game_rank', 0, 2, withscores=True)
print(top_players)

• 时间线排序：将事件的发生时间作为分数，事件内容作为元素，存储在有序集合中，可以按照时间顺序对事件进行排序。

 

Redis 使用

Redis 使用

using StackExchange.Redis;
using Newtonsoft.Json;

namespace Redis
{
    public class RedisService
    {
        #region Init

        private readonly RedisConfigModel redisConfigModel;

        public static volatile ConnectionMultiplexer redisConnection;

        private readonly object redisConnectionLock = new object();

        public RedisService()
        {
            var redisConfig = AppSettings.app<RedisConfigModel>("RedisConfig");
            if (string.IsNullOrEmpty(redisConfig?.Host))
            {
                throw new Exception("redis config is empty");
            }
            this.redisConfigModel = redisConfig;
            redisConnection = GetRedisConnection();
        }
        public RedisService(RedisConfigModel configModel)
        {
            if (string.IsNullOrEmpty(configModel?.Host))
            {
                throw new Exception("redis config is empty");
            }
            this.redisConfigModel = configModel;
            redisConnection = GetRedisConnection();
        }

        private ConnectionMultiplexer GetRedisConnection()
        {
            if (redisConnection != null && redisConnection.IsConnected)
            {
                return redisConnection;
            }
            lock (redisConnectionLock)
            {
                if (redisConnection != null)
                {
                    //释放redis连接
                    redisConnection.Dispose();
                }
                redisConnection = GetRedisConnection(this.redisConfigModel);
            }
            return redisConnection;
        }

        public ConnectionMultiplexer GetRedisConnection(RedisConfigModel configModel)
        {
            var url = configModel?.Host;
            try
            {
                if (!string.IsNullOrEmpty(configModel?.Port))
                {
                    url = $"{url}:{configModel.Port}";
                }
                var config = new ConfigurationOptions
                {
                    AbortOnConnectFail = false,
                    AllowAdmin = true,
                    ConnectTimeout = 15000,//改成15s
                    SyncTimeout = 5000,
                    EndPoints = { url }
                };
                if (!string.IsNullOrEmpty(configModel?.Pwd))
                {
                    config.Password = configModel.Pwd;
                }
                if (configModel.Db.HasValue)
                {
                    config.DefaultDatabase = configModel.Db.Value;
                }
                return ConnectionMultiplexer.Connect(config);
            }
            catch (Exception)
            {
                throw new Exception($"{url}Redis服务未启用，请开启该服务，并且请注意端口号");
            }
        }
        #endregion

        #region 基本方法
        /// <summary>
        /// 写入redis
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool Set(string key, string value)
        {
            var result = redisConnection.GetDatabase().StringSet(key, value);
            return result;
        }
        /// <summary>
        /// 写入redis
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="timeSpan"></param>
        /// <returns></returns>
        public static bool Set(string key, string value, TimeSpan timeSpan)
        {
            var result = redisConnection.GetDatabase().StringSet(key, value, timeSpan);
            return result;
        }
        /// <summary>
        /// 写入redis
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool Set<T>(string key, T value)
        {
            var result = redisConnection.GetDatabase().StringSet(key, SerializationHelper.SerializeJson(value));
            return result;
        }
        /// <summary>
        /// 写入redis
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="timeSpan"></param>
        /// <returns></returns>
        public static bool Set<T>(string key, T value, TimeSpan timeSpan)
        {
            var result = redisConnection.GetDatabase().StringSet(key, SerializationHelper.SerializeJson(value), timeSpan);
            return result;
        }
        /// <summary>
        /// 获取redis
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string Get(string key)
        {
            var result = redisConnection.GetDatabase().StringGet(key).ToString();
            return result;
        }
        /// <summary>
        /// 获取redis
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public static T Get<T>(string key)
        {
            var value = redisConnection.GetDatabase().StringGet(key);
            if (value.HasValue)
            {
                return SerializationHelper.DeserializeJson<T>(value.ToString());
            }
            return default(T);
        }
        /// <summary>
        /// 模糊查询Key
        /// </summary>
        /// <param name="searchKey"></param>
        /// <returns></returns>
        public static List<string> SearchKeys(string searchKey)
        {
            var redisResult = GetKeys(searchKey);
            if (!redisResult.IsNull)
            {
                string[] keyList = (string[])redisResult;
                return keyList.ToList();
            }
            return new List<string>();
        }
        #endregion

        #region 获取组数据
        /// <summary>
        /// 组名前缀，防止和普通key重复
        /// </summary>
        private readonly static string groupPrefix = "g:";
        /// <summary>
        /// Hash前缀，防止和普通key重复
        /// </summary>
        private readonly static string hashPrefix = "h:";
        /// <summary>
        /// 添加组对象,不覆盖
        /// </summary>
        /// <param name="group">组名</param>
        /// <param name="value">值</param>
        /// <param name="keyAry">对象名</param>
        public static bool AddGroup<T>(string group, T value, params string[] keyAry)
        {
            var result = true;
            var key = $"{groupPrefix}{group}:{string.Join(":", keyAry)}";
            if (value is string cacheValue)
            {
                result = Set(key, cacheValue);
            }
            else
            {
                result = Set(key, value);
            }
            return result;
        }

        /// <summary>
        /// 添加组对象,不覆盖
        /// </summary>
        /// <param name="group">组名</param>
        /// <param name="value">值</param>
        /// <param name="timeSpan">过期时间</param>
        /// <param name="keyAry">对象名</param>
        public static bool AddGroup<T>(string group, T value, TimeSpan timeSpan, params string[] keyAry)
        {
            var result = true;
            var key = $"{groupPrefix}{group}:{string.Join(":", keyAry)}";
            if (value is string cacheValue)
            {
                result = Set(key, cacheValue, timeSpan);
            }
            else
            {
                result = Set(key, value, timeSpan);
            }
            return result;
        }

        /// <summary>
        /// 添加组对象,覆盖
        /// </summary>
        /// <param name="group">组名</param>
        /// <param name="value">值</param>
        /// <param name="keyAry">对象名</param>
        public static bool SetGroup<T>(string group, T value, params string[] keyAry)
        {
            var result = AddGroup<T>(group, value, keyAry);
            return result;
        }

        /// <summary>
        /// 添加组对象,覆盖
        /// </summary>
        /// <param name="group">组名</param>
        /// <param name="value">值</param>
        /// <param name="timeSpan">过期时间</param>
        /// <param name="keyAry">对象名</param>
        public static bool SetGroup<T>(string group, T value, TimeSpan timeSpan, params string[] keyAry)
        {
            var result = AddGroup<T>(group, value, timeSpan, keyAry);
            return result;
        }

        /// <summary>
        /// 获取一个组的所有对象合并过的集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="group">组名</param>
        /// <returns></returns>
        public static List<T> GetGroupList<T>(string group)
        {
            var redisResult = GetKeys($"{groupPrefix}{group}:*");
            var result = new List<T>();
            if (!redisResult.IsNull)
            {
                RedisKey[] preSult = (RedisKey[])redisResult;
                var tags = redisConnection.GetDatabase().StringGet(preSult);
                foreach (var tag in tags)
                {
                    if (tag.HasValue)
                    {
                        var groupList = SerializationHelper.DeserializeJson<List<T>>(tag.ToString());
                        if (groupList?.Count > 0)
                        {
                            result.AddRange(groupList);
                        }
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// 获取一个组的其中子项合并过的集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="group">组名</param>
        /// <param name="keyAry">对象</param>
        /// <returns></returns>
        public static List<T> GetFreeGroupList<T>(string group, params string[] keyAry)
        {
            var redisResult = GetKeys($"{groupPrefix}{group}:{string.Join(":", keyAry)}");
            var result = new List<T>();
            if (!redisResult.IsNull)
            {
                RedisKey[] preSult = (RedisKey[])redisResult;
                var tags = redisConnection.GetDatabase().StringGet(preSult);
                foreach (var tag in tags)
                {
                    if (tag.HasValue)
                    {
                        var groupList = SerializationHelper.DeserializeJson<List<T>>(tag.ToString());
                        if (groupList?.Count > 0)
                        {
                            result.AddRange(groupList);
                        }
                    }
                }
            }
            return result;
        }


        /// <summary>
        /// 获取一个组的其中一个对象值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="group">组名</param>
        /// <param name="key">对象名</param>
        /// <returns></returns>
        public static T GetGroup<T>(string group, params string[] key)
        {
            var result = Get<T>($"{groupPrefix}{group}:{string.Join(":", key)}");
            return result;
        }

        /// <summary>
        /// 获取一个组的其中一个对象值(List)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="group">组名</param>
        /// <param name="keyAry">对象名</param>
        /// <returns></returns>
        public static List<T> GetGroupList<T>(string group, params string[] keyAry)
        {
            var result = Get<List<T>>($"{groupPrefix}{group}:{string.Join(":", keyAry)}");
            return result ?? new List<T>();
        }
        /// <summary>
        /// 删除一个组所有的对象
        /// </summary>
        /// <param name="group">组名</param>
        /// <returns></returns>
        public static bool RemoveGroup(string group)
        {
            var redisResult = GetKeys($"{groupPrefix}{group}:*");
            try
            {
                if (!redisResult.IsNull)
                {
                    RedisKey[] preSult = (RedisKey[])redisResult;
                    return redisConnection.GetDatabase().KeyDelete(preSult) > 0;
                }
            }
            catch (Exception ex)
            {
                JHSC.Log.Log4Helper.Log.WriteLog("redis remove group error", ex);
                return false;
            }
            return false;
        }

        /// <summary>
        /// 删除一个组的其中子项
        /// </summary>
        /// <param name="group">组名</param>
        /// <param name="keyAry">对象名</param>
        /// <returns></returns>
        public static bool RemoveFreeGroup(string group, params string[] keyAry)
        {
            var redisResult = GetKeys($"{groupPrefix}{group}:{string.Join(":", keyAry)}");
            try
            {
                if (!redisResult.IsNull)
                {
                    RedisKey[] preSult = (RedisKey[])redisResult;
                    return redisConnection.GetDatabase().KeyDelete(preSult) > 0;
                }
            }
            catch (Exception ex)
            {
                JHSC.Log.Log4Helper.Log.WriteLog("redis remove group error", ex);
                return false;
            }
            return false;
        }
        /// <summary>
        /// 删除一个组其中一个对象
        /// </summary>
        /// <param name="group">组名</param>
        /// <param name="keyAry">对象名</param>
        /// <returns></returns>
        public static bool RemoveGroup(string group, params string[] keyAry)
        {
            var result = redisConnection.GetDatabase().KeyDelete($"{groupPrefix}{group}:{string.Join(":", keyAry)}");
            return result;
        }
        #endregion

        #region 队列
        /// <summary>
        /// 往前写入队列信息
        /// </summary>
        /// <param name="qKey"></param>
        /// <param name="qValue"></param>
        public static void LWriteQueue(string qKey, string qValue)
        {
            redisConnection.GetDatabase().ListLeftPush(qKey, qValue);
        }
        /// <summary>
        /// 往前写入队列信息
        /// </summary>
        /// <param name="qKey"></param>
        /// <param name="qValue"></param>
        public static void LWriteQueue(string qKey, object qValue)
        {
            var value = SerializationHelper.SerializeJson(qValue);
            LWriteQueue(qKey, value);
        }
        /// <summary>
        /// 往前读取队列信息
        /// </summary>
        /// <param name="qKey"></param>
        /// <param name="qValue"></param>
        public static string LReadQueue(string qKey)
        {
            var result = redisConnection.GetDatabase().ListLeftPop(qKey);
            if (result.HasValue)
            {
                return result.ToString();
            }
            return "";
        }
        /// <summary>
        /// 往前读取队列信息
        /// </summary>
        /// <param name="qKey"></param>
        /// <param name="qValue"></param>
        public static T LReadQueue<T>(string qKey)
        {
            var result = redisConnection.GetDatabase().ListLeftPop(qKey);
            if (result.HasValue)
            {
                return SerializationHelper.DeserializeJson<T>(result.ToString());
            }
            return default(T);
        }
        /// <summary>
        /// 往后写入队列信息
        /// </summary>
        /// <param name="qKey"></param>
        /// <param name="qValue"></param>
        public static void RWriteQueue(string qKey, string qValue)
        {
            redisConnection.GetDatabase().ListRightPush(qKey, qValue);
        }
        /// <summary>
        /// 往后写入队列信息
        /// </summary>
        /// <param name="qKey"></param>
        /// <param name="qValue"></param>
        public static void RWriteQueue(string qKey, object qValue)
        {
            var value = SerializationHelper.SerializeJson(qValue);
            RWriteQueue(qKey, value);
        }
        /// <summary>
        /// 往后读取队列信息
        /// </summary>
        /// <param name="qKey"></param>
        /// <param name="qValue"></param>
        public static string RReadQueue(string qKey)
        {
            var result = redisConnection.GetDatabase().ListRightPop(qKey);
            if (result.HasValue)
            {
                return result.ToString();
            }
            return "";
        }
        /// <summary>
        /// 往后读取队列信息
        /// </summary>
        /// <param name="qKey"></param>
        /// <param name="qValue"></param>
        public static T RReadQueue<T>(string qKey)
        {
            var result = redisConnection.GetDatabase().ListRightPop(qKey);
            if (result.HasValue)
            {
                return SerializationHelper.DeserializeJson<T>(result.ToString());
            }
            return default(T);
        }
        #endregion

        #region 公用方法
        /// <summary>
        /// 模糊搜索Keys
        /// </summary>
        /// <param name="searchKey"></param>
        /// <returns></returns>
        private static RedisResult GetKeys(string searchKey)
        {
            var result = redisConnection.GetDatabase().ScriptEvaluate(LuaScript.Prepare(
                               " local res = redis.call('KEYS', @keypattern) " +
                               " return res "), new { @keypattern = searchKey });
            return result;
        }
        #endregion

        #region Hash
        /// <summary>
        /// Set Hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static bool SetHash(string hashId, string key, string value)
        {
            var result = false;
            try
            {
                result = redisConnection.GetDatabase().HashSet(hashId, key, value);
            }
            catch (Exception ex)
            {

            }
            return result;
        }
        /// <summary>
        /// Set Hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static bool SetHash(string hashId, string key, byte[] value)
        {
            var result = false;
            try
            {
                result = redisConnection.GetDatabase().HashSet(hashId, key, value);
            }
            catch (Exception ex)
            {

            }
            return result;
        }
        /// <summary>
        /// 批量Set Hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="valueDict"></param>
        public static bool SetHashDict(string hashId, Dictionary<string, string> valueDict)
        {
            var result = false;
            try
            {
                redisConnection.GetDatabase().HashSet(hashId, valueDict.Select(s => new HashEntry(s.Key, s.Value)).ToArray());
                result = true;
            }
            catch (Exception ex)
            {

            }
            return result;
        }
        /// <summary>
        /// 批量Set Hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="valueDict"></param>
        public static bool SetHashDict(string hashId, Dictionary<string, byte[]> valueDict)
        {
            var result = false;
            try
            {
                redisConnection.GetDatabase().HashSet(hashId, valueDict.Select(s => new HashEntry(s.Key, s.Value)).ToArray());
                result = true;
            }
            catch (Exception ex)
            {

            }
            return result;
        }
        /// <summary>
        /// 添加组Hash值,指定字段为Key,覆盖
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="group">组名</param>
        /// <param name="list">数据源</param>
        /// <param name="fieldName">指定字段为key</param>
        /// <param name="keyAry">对象名</param>
        /// <returns></returns>
        public static bool SetHashAllKeyList<T>(string group, List<T> list, string fieldName, params string[] keyAry)
        {
            var result = false;
            if (list.Count() > 0)
            {
                try
                {
                    var dict = ChangeListToDict(list, fieldName);
                    if (dict?.Count() > 0)
                    {
                        result = SetHashDict($"{hashPrefix}{group}:{string.Join(":", keyAry)}", dict);
                    }
                }
                catch (Exception ex)
                {

                }
            }
            return result;
        }
        /// <summary>
        /// 删除 HashId
        /// </summary>
        /// <param name="hashId"></param>
        public static void RemoveHashId(string hashId)
        {
            redisConnection.GetDatabase().KeyDelete(hashId);
        }
        /// <summary>
        /// 删除 HashKey
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="keyAry"></param>
        public static void RemoveHash(string hashId, params string[] keyAry)
        {
            redisConnection.GetDatabase().HashDelete(hashId, keyAry.Select(s => (RedisValue)s).ToArray());
        }

        /// <summary>
        /// 获取Hash组值
        /// </summary>
        /// <param name="group">HashId组名</param>
        /// <param name="key">主键</param>
        /// <param name="keyAry">对象名</param>
        /// <returns></returns>
        public static T GetHash<T>(string group, string key, params string[] keyAry)
        {
            var result = default(T);
            var value = redisConnection.GetDatabase().HashGet($"{hashPrefix}{group}:{string.Join(":", keyAry)}", key);
            if (value.HasValue)
            {
                result = JsonConvert.DeserializeObject<T>(value.ToString());
            }
            return result;
        }
        /// <summary>
        /// 获取Hash组所有值
        /// </summary>
        /// <param name="group">HashId组名</param>
        /// <param name="keyAry">对象名</param>
        /// <returns></returns>
        public static List<T> GetHashList<T>(string group, params string[] keyAry)
        {
            var result = new List<T>();
            var list = redisConnection.GetDatabase().HashGetAll($"{hashPrefix}{group}:{string.Join(":", keyAry)}").Select(s => s.Value).ToArray();
            if (list?.Length > 0)
            {
                var jsonStr = $"[{string.Join(",", list)}]";
                result = JsonConvert.DeserializeObject<List<T>>(jsonStr);
            }
            return result;
        }
        /// <summary>
        /// 获取 Hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="keyAry"></param>
        /// <returns></returns>
        public static HashEntry[] GetHashEntry(string hashId, params string[] keyAry)
        {
            if (keyAry?.Length > 0)
            {
                var valueAry = redisConnection.GetDatabase().HashGet(hashId, keyAry.Select(s => (RedisValue)s).ToArray());
                var result = new List<HashEntry>();
                for (var i = 0; i < keyAry.Length; i++)
                {
                    if (valueAry[i].HasValue)
                    {
                        result.Add(new HashEntry(keyAry[i], valueAry[i]));
                    }
                }
                return result.ToArray();
            }
            else
            {
                var result = redisConnection.GetDatabase().HashGetAll(hashId);
                return result;
            }
        }
        /// <summary>
        /// 获取 Hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="keyAry"></param>
        /// <returns></returns>
        public static Dictionary<string, string> GetHashDict(string hashId, params string[] keyAry)
        {
            var hashAry = GetHashEntry(hashId, keyAry);
            var result = new Dictionary<string, string>();
            foreach (var entry in hashAry)
            {
                result.Add(entry.Name, entry.Value);
            }
            return result;
        }
        /// <summary>
        /// 获取 Hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="keyAry"></param>
        /// <returns></returns>
        public static Dictionary<string, byte[]> GetHashByte(string hashId, params string[] keyAry)
        {
            var hashAry = GetHashEntry(hashId);
            var result = new Dictionary<string, byte[]>();
            foreach (var entry in hashAry)
            {
                result.Add(entry.Name, entry.Value);
            }
            return result;
        }
        /// <summary>
        /// List转Dict
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <param name="field">指定字段为key</param>
        /// <returns></returns>
        private static Dictionary<string, string> ChangeListToDict<T>(List<T> list, string field = "")
        {
            var result = new Dictionary<string, string>();
            if (list?.Count() > 0)
            {
                var fieldAry = new string[0];
                if (!string.IsNullOrEmpty(field))
                {
                    fieldAry = field.Split(',');
                }
                foreach (var model in list)
                {
                    Type type = model.GetType();
                    PropertyInfo[] properties = type.GetProperties();
                    if (properties.Length > 0)
                    {
                        var key = "";
                        if (string.IsNullOrEmpty(field))
                        {
                            var value = properties[0].GetValue(model);  //读取第一个参数作为Key
                            if (value != null)
                            {
                                key = value.ToString();
                            }
                        }
                        else
                        {
                            if (fieldAry?.Length > 0)
                            {
                                var keyAry = new List<string>();
                                foreach (var f in fieldAry)
                                {
                                    var p = type.GetProperty(f);
                                    if (p != null)
                                    {
                                        var value = p.GetValue(model);
                                        if (value != null)
                                        {
                                            keyAry.Add(value.ToString());
                                        }
                                    }
                                }
                                if (keyAry?.Count > 0)
                                {
                                    key = string.Join("_", keyAry);
                                }
                            }
                            else
                            {
                                var p = type.GetProperty(field);
                                if (p != null)
                                {
                                    var value = p.GetValue(model);
                                    if (value != null)
                                    {
                                        key = value.ToString();
                                    }
                                }
                            }
                        }
                        if (!string.IsNullOrEmpty(key))
                        {
                            if (!result.ContainsKey(key))
                            {
                                result.Add(key, JsonConvert.SerializeObject(model));
                            }
                        }
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// List转Key
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <param name="field">指定字段为key</param>
        /// <returns></returns>
        private static List<string> ChangeListToKey<T>(List<T> list, string field = "")
        {
            var result = new List<string>();
            if (list?.Count() > 0)
            {
                var fieldAry = new string[0];
                if (!string.IsNullOrEmpty(field))
                {
                    fieldAry = field.Split(',');
                }
                foreach (var model in list)
                {
                    Type type = model.GetType();
                    PropertyInfo[] properties = type.GetProperties();
                    if (properties.Length > 0)
                    {
                        var key = "";
                        if (string.IsNullOrEmpty(field))
                        {
                            var value = properties[0].GetValue(model);  //读取第一个参数作为Key
                            if (value != null)
                            {
                                key = value.ToString();
                            }
                        }
                        else
                        {
                            if (fieldAry?.Length > 0)
                            {
                                var keyAry = new List<string>();
                                foreach (var f in fieldAry)
                                {
                                    var p = type.GetProperty(f);
                                    if (p != null)
                                    {
                                        var value = p.GetValue(model);
                                        if (value != null)
                                        {
                                            keyAry.Add(value.ToString());
                                        }
                                    }
                                }
                                if (keyAry?.Count > 0)
                                {
                                    key = string.Join("_", keyAry);
                                }
                            }
                            else
                            {
                                var p = type.GetProperty(field);
                                if (p != null)
                                {
                                    var value = p.GetValue(model);
                                    if (value != null)
                                    {
                                        key = value.ToString();
                                    }
                                }
                            }
                        }
                        if (!string.IsNullOrEmpty(key))
                        {
                            result.Add(key);
                        }
                    }
                }
            }
            return result;
        }

        #endregion
    }
}

消息队列

万字长文：选 Redis 还是 MQ，终于说明白了！【转载】_redis消息队列优缺点-CSDN博客