Winform/Csharp中使用StackExchange.Redis连接Redis存取数据并序列化对象/反序列化(支持redis key 模糊搜索)

逃离我推掉我的手 2023-09-30 20:59 6阅读 0赞

## 场景 ##

在winform程序中，需要连接Redis并根据Key进行模糊搜索，对value值进行反序列化为

对象之后进行数据处理和显示。

### ServiceStack.redis ###

这里不使用servicestack.redis，因为这个已经商业化了，会出现每小时6000条数据的限制。

### StackExchange.redis ###

[GitHub - StackExchange/StackExchange.Redis: General purpose redis client][GitHub - StackExchange_StackExchange.Redis_ General purpose redis client]

用法文档

[Basic Usage | StackExchange.Redis][Basic Usage _ StackExchange.Redis]

更多用法可参考官方文档，下面将满足使用需求的写法。

注：

博客：  
[霸道流氓气质的博客\_CSDN博客-C\#,架构之路,SpringBoot领域博主][CSDN_-C_SpringBoot]

## 实现 ##

1、本篇参考如下博客实现连接Redis和序列化对象的过程，并在

工具类方法中添加了模糊搜索key的方法。

C\# StackExchange.Redis 用法总结：

[https://www.cnblogs.com/cang12138/p/8884362.html][https_www.cnblogs.com_cang12138_p_8884362.html]

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

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

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

![5a273556765e43059a27b52fbce9d357.png][]

注意在安装StackExchange.Redis 要选择与当前.Net Framework版本对应的版本，确保依赖项正确

![55ea6010ebbb4238844adc6709e3f7d0.png][]

3、在配置文件App.config中添加redis的连接字符串配置

![fe7169b56bf44b2abc3acc2d8bc68629.png][]

4、添加redis连接帮助类RedisConnectionHelp

using StackExchange.Redis;
    using System;
    using System.Collections.Concurrent;
    using System.Configuration;
    
    namespace RedisHelp
    {
        /// <summary>
        /// ConnectionMultiplexer对象管理帮助类
        /// </summary>
        public static class RedisConnectionHelp
        {
            //系统自定义Key前缀
            public static readonly string SysCustomKey = ConfigurationManager.AppSettings["redisKey"] ?? "";
    
            //"127.0.0.1:6379,allowadmin=true
            private static readonly string RedisConnectionString = ConfigurationManager.ConnectionStrings["RedisExchangeHosts"].ConnectionString;
    
            private static readonly object Locker = new object();
            private static ConnectionMultiplexer _instance;
            private static readonly ConcurrentDictionary<string, ConnectionMultiplexer> ConnectionCache = new ConcurrentDictionary<string, ConnectionMultiplexer>();
    
            /// <summary>
            /// 单例获取
            /// </summary>
            public static ConnectionMultiplexer Instance
            {
                get
                {
                    if (_instance == null)
                    {
                        lock (Locker)
                        {
                            if (_instance == null || !_instance.IsConnected)
                            {
                                _instance = GetManager();
                            }
                        }
                    }
                    return _instance;
                }
            }
    
            /// <summary>
            /// 缓存获取
            /// </summary>
            /// <param name="connectionString"></param>
            /// <returns></returns>
            public static ConnectionMultiplexer GetConnectionMultiplexer(string connectionString)
            {
                if (!ConnectionCache.ContainsKey(connectionString))
                {
                    ConnectionCache[connectionString] = GetManager(connectionString);
                }
                return ConnectionCache[connectionString];
            }
    
            private static ConnectionMultiplexer GetManager(string connectionString = null)
            {
                connectionString = connectionString ?? RedisConnectionString;
                var connect = ConnectionMultiplexer.Connect(connectionString);
    
                //注册如下事件
                connect.ConnectionFailed += MuxerConnectionFailed;
                connect.ConnectionRestored += MuxerConnectionRestored;
                connect.ErrorMessage += MuxerErrorMessage;
                connect.ConfigurationChanged += MuxerConfigurationChanged;
                connect.HashSlotMoved += MuxerHashSlotMoved;
                connect.InternalError += MuxerInternalError;
    
                return connect;
            }
    
            #region 事件
    
            /// <summary>
            /// 配置更改时
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
            {
                Console.WriteLine("Configuration changed: " + e.EndPoint);
            }
    
            /// <summary>
            /// 发生错误时
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
            {
                Console.WriteLine("ErrorMessage: " + e.Message);
            }
    
            /// <summary>
            /// 重新建立连接之前的错误
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
            {
                Console.WriteLine("ConnectionRestored: " + e.EndPoint);
            }
    
            /// <summary>
            /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
            {
                Console.WriteLine("重新连接：Endpoint failed: " + e.EndPoint + ", " + e.FailureType + (e.Exception == null ? "" : (", " + e.Exception.Message)));
            }
    
            /// <summary>
            /// 更改集群
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
            {
                Console.WriteLine("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
            }
    
            /// <summary>
            /// redis类库错误
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
            {
                Console.WriteLine("InternalError:Message" + e.Exception.Message);
            }
    
            #endregion 事件
        }
    }

5、添加redis常用方法工具类

using Newtonsoft.Json;
    using StackExchange.Redis;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Threading.Tasks;
    
    namespace RedisHelp
    {
        /// <summary>
        /// Redis操作
        /// </summary>
        public class RedisHelper
        {
            private int DbNum { get; set; }
            /// <summary>
            /// Redis连接
            /// </summary>
            private readonly ConnectionMultiplexer _conn;
    
            /// <summary>
            /// 设置自定义键
            /// </summary>
            public string CustomKey;
    
            #region 构造函数
    
            public RedisHelper(int dbNum = 0)
                : this(dbNum, null)
            {
            }
    
            public RedisHelper(int dbNum, string readWriteHosts)
            {
                DbNum = dbNum;
                _conn = string.IsNullOrWhiteSpace(readWriteHosts) ?
                        RedisConnectionHelp.Instance :
                        RedisConnectionHelp.GetConnectionMultiplexer(readWriteHosts);
            }
    
            #endregion 构造函数
    
            #region String
    
            #region 同步方法
    
            /// <summary>
            /// 保存单个key value
            /// </summary>
            /// <param name="key">Redis Key</param>
            /// <param name="value">保存的值</param>
            /// <param name="expiry">过期时间</param>
            /// <returns></returns>
            public bool StringSet(string key, string value, TimeSpan? expiry = default(TimeSpan?))
            {
                key = AddSysCustomKey(key);
                return Do(db => db.StringSet(key, value, expiry));
            }
    
            /// <summary>
            /// 保存多个key value
            /// </summary>
            /// <param name="keyValues">键值对</param>
            /// <returns></returns>
            public bool StringSet(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
            {
                List<KeyValuePair<RedisKey, RedisValue>> newkeyValues = keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToList();
                return Do(db => db.StringSet(newkeyValues.ToArray()));
            }
    
            /// <summary>
            /// 保存一个对象
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="obj"></param>
            /// <param name="expiry"></param>
            /// <returns></returns>
            public bool StringSet<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
            {
                key = AddSysCustomKey(key);
                string json = ConvertJson(obj);
                return Do(db => db.StringSet(key, json, expiry));
            }
    
            /// <summary>
            /// 获取单个key的值
            /// </summary>
            /// <param name="key">Redis Key</param>
            /// <returns></returns>
            public string StringGet(string key)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.StringGet(key));
            }
    
            /// <summary>
            /// 获取多个Key
            /// </summary>
            /// <param name="listKey">Redis Key集合</param>
            /// <returns></returns>
            public RedisValue[] StringGet(List<string> listKey)
            {
                List<string> newKeys = listKey.Select(AddSysCustomKey).ToList();
                return Do(db => db.StringGet(ConvertRedisKeys(newKeys)));
            }
    
            /// <summary>
            /// 获取一个key的对象
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public T StringGet<T>(string key)
            {
                key = AddSysCustomKey(key);
                return Do(db => ConvertObj<T>(db.StringGet(key)));
            }
    
            /// <summary>
            /// 为数字增长val
            /// </summary>
            /// <param name="key"></param>
            /// <param name="val">可以为负</param>
            /// <returns>增长后的值</returns>
            public double StringIncrement(string key, double val = 1)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.StringIncrement(key, val));
            }
    
            /// <summary>
            /// 为数字减少val
            /// </summary>
            /// <param name="key"></param>
            /// <param name="val">可以为负</param>
            /// <returns>减少后的值</returns>
            public double StringDecrement(string key, double val = 1)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.StringDecrement(key, val));
            }
    
            #endregion 同步方法
    
            #region 异步方法
    
            /// <summary>
            /// 保存单个key value
            /// </summary>
            /// <param name="key">Redis Key</param>
            /// <param name="value">保存的值</param>
            /// <param name="expiry">过期时间</param>
            /// <returns></returns>
            public async Task<bool> StringSetAsync(string key, string value, TimeSpan? expiry = default(TimeSpan?))
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.StringSetAsync(key, value, expiry));
            }
    
            /// <summary>
            /// 保存多个key value
            /// </summary>
            /// <param name="keyValues">键值对</param>
            /// <returns></returns>
            public async Task<bool> StringSetAsync(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
            {
                List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
                    keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToList();
                return await Do(db => db.StringSetAsync(newkeyValues.ToArray()));
            }
    
            /// <summary>
            /// 保存一个对象
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="obj"></param>
            /// <param name="expiry"></param>
            /// <returns></returns>
            public async Task<bool> StringSetAsync<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
            {
                key = AddSysCustomKey(key);
                string json = ConvertJson(obj);
                return await Do(db => db.StringSetAsync(key, json, expiry));
            }
    
            /// <summary>
            /// 获取单个key的值
            /// </summary>
            /// <param name="key">Redis Key</param>
            /// <returns></returns>
            public async Task<string> StringGetAsync(string key)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.StringGetAsync(key));
            }
    
            /// <summary>
            /// 获取多个Key
            /// </summary>
            /// <param name="listKey">Redis Key集合</param>
            /// <returns></returns>
            public async Task<RedisValue[]> StringGetAsync(List<string> listKey)
            {
                List<string> newKeys = listKey.Select(AddSysCustomKey).ToList();
                return await Do(db => db.StringGetAsync(ConvertRedisKeys(newKeys)));
            }
    
            /// <summary>
            /// 获取一个key的对象
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public async Task<T> StringGetAsync<T>(string key)
            {
                key = AddSysCustomKey(key);
                string result = await Do(db => db.StringGetAsync(key));
                return ConvertObj<T>(result);
            }
    
            /// <summary>
            /// 为数字增长val
            /// </summary>
            /// <param name="key"></param>
            /// <param name="val">可以为负</param>
            /// <returns>增长后的值</returns>
            public async Task<double> StringIncrementAsync(string key, double val = 1)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.StringIncrementAsync(key, val));
            }
    
            /// <summary>
            /// 为数字减少val
            /// </summary>
            /// <param name="key"></param>
            /// <param name="val">可以为负</param>
            /// <returns>减少后的值</returns>
            public async Task<double> StringDecrementAsync(string key, double val = 1)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.StringDecrementAsync(key, val));
            }
    
            #endregion 异步方法
    
            #endregion String
    
            #region Hash
    
            #region 同步方法
    
            /// <summary>
            /// 判断某个数据是否已经被缓存
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public bool HashExists(string key, string dataKey)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.HashExists(key, dataKey));
            }
    
            /// <summary>
            /// 存储数据到hash表
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public bool HashSet<T>(string key, string dataKey, T t)
            {
                key = AddSysCustomKey(key);
                return Do(db =>
                {
                    string json = ConvertJson(t);
                    return db.HashSet(key, dataKey, json);
                });
            }
    
            /// <summary>
            /// 移除hash中的某值
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public bool HashDelete(string key, string dataKey)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.HashDelete(key, dataKey));
            }
    
            /// <summary>
            /// 移除hash中的多个值
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKeys"></param>
            /// <returns></returns>
            public long HashDelete(string key, List<RedisValue> dataKeys)
            {
                key = AddSysCustomKey(key);
                //List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
                return Do(db => db.HashDelete(key, dataKeys.ToArray()));
            }
    
            /// <summary>
            /// 从hash表获取某个值
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public string HashGet(string key, string dataKey)
            {
                key = AddSysCustomKey(key);
                return Do(db =>
                {
                    string value = db.HashGet(key, dataKey);
                    return value;
                });
            }
    
            /// <summary>
            /// 从hash表获取Model
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public T HashGet<T>(string key, string dataKey)
            {
                key = AddSysCustomKey(key);
                return Do(db =>
                {
                    string value = db.HashGet(key, dataKey);
                    return ConvertObj<T>(value);
                });
            }
    
            /// <summary>
            /// 从hash表获取List
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public IList<T> HashGetList<T>(string key)
            {
                key = AddSysCustomKey(key);
                return Do(db =>
                {
                    RedisValue[] values = db.HashValues(key);
                    return ConvetList<T>(values);
                });
            }
    
            /// <summary>
            /// 为数字增长val
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <param name="val">可以为负</param>
            /// <returns>增长后的值</returns>
            public double HashIncrement(string key, string dataKey, double val = 1)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.HashIncrement(key, dataKey, val));
            }
    
            /// <summary>
            /// 为数字减少val
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <param name="val">可以为负</param>
            /// <returns>减少后的值</returns>
            public double HashDecrement(string key, string dataKey, double val = 1)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.HashDecrement(key, dataKey, val));
            }
    
            /// <summary>
            /// 获取hashkey所有Redis key
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public List<T> HashKeys<T>(string key)
            {
                key = AddSysCustomKey(key);
                return Do(db =>
                {
                    RedisValue[] values = db.HashKeys(key);
                    return ConvetList<T>(values);
                });
            }
    
            #endregion 同步方法
    
            #region 异步方法
    
            /// <summary>
            /// 判断某个数据是否已经被缓存
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public async Task<bool> HashExistsAsync(string key, string dataKey)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.HashExistsAsync(key, dataKey));
            }
    
            /// <summary>
            /// 存储数据到hash表
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public async Task<bool> HashSetAsync<T>(string key, string dataKey, T t)
            {
                key = AddSysCustomKey(key);
                return await Do(db =>
                {
                    string json = ConvertJson(t);
                    return db.HashSetAsync(key, dataKey, json);
                });
            }
    
            /// <summary>
            /// 移除hash中的某值
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public async Task<bool> HashDeleteAsync(string key, string dataKey)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.HashDeleteAsync(key, dataKey));
            }
    
            /// <summary>
            /// 移除hash中的多个值
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKeys"></param>
            /// <returns></returns>
            public async Task<long> HashDeleteAsync(string key, List<RedisValue> dataKeys)
            {
                key = AddSysCustomKey(key);
                //List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
                return await Do(db => db.HashDeleteAsync(key, dataKeys.ToArray()));
            }
    
            /// <summary>
            /// 从hash表获取数据
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public async Task<T> HashGeAsync<T>(string key, string dataKey)
            {
                key = AddSysCustomKey(key);
                string value = await Do(db => db.HashGetAsync(key, dataKey));
                return ConvertObj<T>(value);
            }
    
            /// <summary>
            /// 为数字增长val
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <param name="val">可以为负</param>
            /// <returns>增长后的值</returns>
            public async Task<double> HashIncrementAsync(string key, string dataKey, double val = 1)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.HashIncrementAsync(key, dataKey, val));
            }
    
            /// <summary>
            /// 为数字减少val
            /// </summary>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <param name="val">可以为负</param>
            /// <returns>减少后的值</returns>
            public async Task<double> HashDecrementAsync(string key, string dataKey, double val = 1)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.HashDecrementAsync(key, dataKey, val));
            }
    
            /// <summary>
            /// 获取hashkey所有Redis key
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public async Task<List<T>> HashKeysAsync<T>(string key)
            {
                key = AddSysCustomKey(key);
                RedisValue[] values = await Do(db => db.HashKeysAsync(key));
                return ConvetList<T>(values);
            }
    
            #endregion 异步方法
    
            #endregion Hash
    
            #region List
    
            #region 同步方法
    
            /// <summary>
            /// 移除指定ListId的内部List的值
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public void ListRemove<T>(string key, T value)
            {
                key = AddSysCustomKey(key);
                Do(db => db.ListRemove(key, ConvertJson(value)));
            }
    
            /// <summary>
            /// 获取指定key的List
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public List<T> ListRange<T>(string key)
            {
                key = AddSysCustomKey(key);
                return Do(redis =>
                {
                    var values = redis.ListRange(key);
                    return ConvetList<T>(values);
                });
            }
    
            /// <summary>
            /// 入队
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public void ListRightPush<T>(string key, T value)
            {
                key = AddSysCustomKey(key);
                Do(db => db.ListRightPush(key, ConvertJson(value)));
            }
    
            /// <summary>
            /// 出队
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public T ListRightPop<T>(string key)
            {
                key = AddSysCustomKey(key);
                return Do(db =>
                 {
                     var value = db.ListRightPop(key);
                     return ConvertObj<T>(value);
                 });
            }
    
            /// <summary>
            /// 入栈
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public void ListLeftPush<T>(string key, T value)
            {
                key = AddSysCustomKey(key);
                Do(db => db.ListLeftPush(key, ConvertJson(value)));
            }
    
            /// <summary>
            /// 出栈
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public T ListLeftPop<T>(string key)
            {
                key = AddSysCustomKey(key);
                return Do(db =>
                {
                    var value = db.ListLeftPop(key);
                    return ConvertObj<T>(value);
                });
            }
    
            /// <summary>
            /// 获取集合中的数量
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public long ListLength(string key)
            {
                key = AddSysCustomKey(key);
                return Do(redis => redis.ListLength(key));
            }
    
            #endregion 同步方法
    
            #region 异步方法
    
            /// <summary>
            /// 移除指定ListId的内部List的值
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public async Task<long> ListRemoveAsync<T>(string key, T value)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.ListRemoveAsync(key, ConvertJson(value)));
            }
    
            /// <summary>
            /// 获取指定key的List
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public async Task<List<T>> ListRangeAsync<T>(string key)
            {
                key = AddSysCustomKey(key);
                var values = await Do(redis => redis.ListRangeAsync(key));
                return ConvetList<T>(values);
            }
    
            /// <summary>
            /// 入队
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public async Task<long> ListRightPushAsync<T>(string key, T value)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.ListRightPushAsync(key, ConvertJson(value)));
            }
    
            /// <summary>
            /// 出队
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public async Task<T> ListRightPopAsync<T>(string key)
            {
                key = AddSysCustomKey(key);
                var value = await Do(db => db.ListRightPopAsync(key));
                return ConvertObj<T>(value);
            }
    
            /// <summary>
            /// 入栈
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public async Task<long> ListLeftPushAsync<T>(string key, T value)
            {
                key = AddSysCustomKey(key);
                return await Do(db => db.ListLeftPushAsync(key, ConvertJson(value)));
            }
    
            /// <summary>
            /// 出栈
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public async Task<T> ListLeftPopAsync<T>(string key)
            {
                key = AddSysCustomKey(key);
                var value = await Do(db => db.ListLeftPopAsync(key));
                return ConvertObj<T>(value);
            }
    
            /// <summary>
            /// 获取集合中的数量
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public async Task<long> ListLengthAsync(string key)
            {
                key = AddSysCustomKey(key);
                return await Do(redis => redis.ListLengthAsync(key));
            }
    
            #endregion 异步方法
    
            #endregion List
    
            #region SortedSet 有序集合
    
            #region 同步方法
    
            /// <summary>
            /// 添加
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            /// <param name="score"></param>
            public bool SortedSetAdd<T>(string key, T value, double score)
            {
                key = AddSysCustomKey(key);
                return Do(redis => redis.SortedSetAdd(key, ConvertJson<T>(value), score));
            }
    
            /// <summary>
            /// 删除
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public bool SortedSetRemove<T>(string key, T value)
            {
                key = AddSysCustomKey(key);
                return Do(redis => redis.SortedSetRemove(key, ConvertJson(value)));
            }
    
            /// <summary>
            /// 获取全部
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public List<T> SortedSetRangeByRank<T>(string key)
            {
                key = AddSysCustomKey(key);
                return Do(redis =>
                {
                    var values = redis.SortedSetRangeByRank(key);
                    return ConvetList<T>(values);
                });
            }
    
            /// <summary>
            /// 获取集合中的数量
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public long SortedSetLength(string key)
            {
                key = AddSysCustomKey(key);
                return Do(redis => redis.SortedSetLength(key));
            }
    
            #endregion 同步方法
    
            #region 异步方法
    
            /// <summary>
            /// 添加
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            /// <param name="score"></param>
            public async Task<bool> SortedSetAddAsync<T>(string key, T value, double score)
            {
                key = AddSysCustomKey(key);
                return await Do(redis => redis.SortedSetAddAsync(key, ConvertJson<T>(value), score));
            }
    
            /// <summary>
            /// 删除
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public async Task<bool> SortedSetRemoveAsync<T>(string key, T value)
            {
                key = AddSysCustomKey(key);
                return await Do(redis => redis.SortedSetRemoveAsync(key, ConvertJson(value)));
            }
    
            /// <summary>
            /// 获取全部
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public async Task<List<T>> SortedSetRangeByRankAsync<T>(string key)
            {
                key = AddSysCustomKey(key);
                var values = await Do(redis => redis.SortedSetRangeByRankAsync(key));
                return ConvetList<T>(values);
            }
    
            /// <summary>
            /// 获取集合中的数量
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public async Task<long> SortedSetLengthAsync(string key)
            {
                key = AddSysCustomKey(key);
                return await Do(redis => redis.SortedSetLengthAsync(key));
            }
    
            #endregion 异步方法
    
            #endregion SortedSet 有序集合
    
            #region key
    
            /// <summary>
            /// 删除单个key
            /// </summary>
            /// <param name="key">redis key</param>
            /// <returns>是否删除成功</returns>
            public bool KeyDelete(string key)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.KeyDelete(key));
            }
    
            /// <summary>
            /// 删除多个key
            /// </summary>
            /// <param name="keys">rediskey</param>
            /// <returns>成功删除的个数</returns>
            public long KeyDelete(List<string> keys)
            {
                List<string> newKeys = keys.Select(AddSysCustomKey).ToList();
                return Do(db => db.KeyDelete(ConvertRedisKeys(newKeys)));
            }
    
            /// <summary>
            /// 模糊搜索keys
            /// </summary>
            /// <param name="pattern">表达式</param>
            public IEnumerable<RedisKey> KeysSearch(string pattern,int dbNum)
            {
                // get the target server
                var server = GetServer(dbNum);
    
                return server.Keys(pattern: pattern);
    
            }
    
            /// <summary>
            /// 判断key是否存储
            /// </summary>
            /// <param name="key">redis key</param>
            /// <returns></returns>
            public bool KeyExists(string key)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.KeyExists(key));
            }
    
            /// <summary>
            /// 重新命名key
            /// </summary>
            /// <param name="key">就的redis key</param>
            /// <param name="newKey">新的redis key</param>
            /// <returns></returns>
            public bool KeyRename(string key, string newKey)
            {
                key = AddSysCustomKey(key);
                return Do(db => db.KeyRename(key, newKey));
            }
    
            /// <summary>
            /// 设置Key的时间
            /// </summary>
            /// <param name="key">redis key</param>
            /// <param name="expiry"></param>
            /// <returns></returns>
            public bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
            {
                key = AddSysCustomKey(key);
                return Do(db => db.KeyExpire(key, expiry));
            }
    
            #endregion key
    
            #region 发布订阅
    
            /// <summary>
            /// Redis发布订阅  订阅
            /// </summary>
            /// <param name="subChannel"></param>
            /// <param name="handler"></param>
            public void Subscribe(string subChannel, Action<RedisChannel, RedisValue> handler = null)
            {
                ISubscriber sub = _conn.GetSubscriber();
                sub.Subscribe(subChannel, (channel, message) =>
                {
                    //接收订阅消息，处理逻辑
                    if (handler == null)
                    {
                        Console.WriteLine(subChannel + " 订阅收到消息：" + message);
                    }
                    else
                    {
                        handler(channel, message);
                    }
                });
                //写法二
                sub.Subscribe(subChannel, new Action<RedisChannel, RedisValue>((channel, message) =>
                {
                    Console.WriteLine(subChannel + " 订阅收到消息：" + message);
                }));
                //写法三
                sub.Subscribe(subChannel, new Action<RedisChannel, RedisValue>(GetMessage));
            }
    
            /// <summary>
            /// 获取订阅消息（写法三）
            /// </summary>
            /// <param name="channel"></param>
            /// <param name="message"></param>
            static void GetMessage(RedisChannel channel, RedisValue message)
            {
                Console.WriteLine(channel + " 订阅收到消息：" + message);
            }
    
            /// <summary>
            /// Redis发布订阅  发布
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="channel"></param>
            /// <param name="msg"></param>
            /// <returns></returns>
            public long Publish<T>(string channel, T msg)
            {
                ISubscriber sub = _conn.GetSubscriber();
                return sub.Publish(channel, ConvertJson(msg));
            }
    
            /// <summary>
            /// Redis发布订阅  取消订阅
            /// </summary>
            /// <param name="channel"></param>
            public void Unsubscribe(string channel)
            {
                ISubscriber sub = _conn.GetSubscriber();
                sub.Unsubscribe(channel);
            }
    
            /// <summary>
            /// Redis发布订阅  取消全部订阅
            /// </summary>
            public void UnsubscribeAll()
            {
                ISubscriber sub = _conn.GetSubscriber();
                sub.UnsubscribeAll();
            }
    
            #endregion 发布订阅
    
            #region 其他
            /// <summary>
            /// 获取事物
            /// </summary>
            /// <returns></returns>
            public ITransaction CreateTransaction()
            {
                return GetDatabase().CreateTransaction();
            }
    
            /// <summary>
            /// 获取批处理（管道模式）
            /// </summary>
            /// <returns></returns>
            public IBatch CreateBatch()
            {
                return GetDatabase().CreateBatch();
            }
    
            public IDatabase GetDatabase()
            {
                return _conn.GetDatabase(DbNum);
            }
    
            public IServer GetServer(int dbNum)
            {
                return _conn.GetServer(_conn.GetEndPoints()[dbNum]);
            }
    
            /// <summary>
            /// 设置前缀
            /// </summary>
            /// <param name="customKey">自定义键</param>
            public void SetSysCustomKey(string customKey)
            {
                CustomKey = customKey;
            }
    
            #endregion 其他
    
            #region 辅助方法
            /// <summary>
            /// 添加自定义键
            /// </summary>
            /// <param name="oldKey"></param>
            /// <returns></returns>
            private string AddSysCustomKey(string oldKey)
            {
                var prefixKey = CustomKey ?? RedisConnectionHelp.SysCustomKey;
                return prefixKey + oldKey;
            }
    
            private T Do<T>(Func<IDatabase, T> func)
            {
                var database = _conn.GetDatabase(DbNum);
                return func(database);
            }
    
            /// <summary>
            /// 序列化
            /// </summary>
            /// <typeparam name="T">类</typeparam>
            /// <param name="value">值</param>
            /// <returns></returns>
            private string ConvertJson<T>(T value)
            {
                string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
                return result;
            }
    
            /// <summary>
            /// 反序列化
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="value"></param>
            /// <returns></returns>
            private T ConvertObj<T>(RedisValue value)
            {
                return JsonConvert.DeserializeObject<T>(value);
            }
    
            private List<T> ConvetList<T>(RedisValue[] values)
            {
                List<T> result = new List<T>();
                foreach (var item in values)
                {
                    var model = ConvertObj<T>(item);
                    result.Add(model);
                }
                return result;
            }
    
            private RedisKey[] ConvertRedisKeys(List<string> redisKeys)
            {
                return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
            }
    
            #endregion 辅助方法
        }
    }

工具类中方法较多，但满足我们使用需求的就几个足够。

不同的是新增了一个模糊搜索key的方法。

存取数据和序列化对象示例

string str = "测试";
                redis.StringSet("name", str);
                string str1 = redis.StringGet("name");
                redis.StringSet("name_two", str, TimeSpan.FromSeconds(10));//设置时间，10s后过期。
                Console.WriteLine("string Key：{0}，Value：{1}", "A", str1);
    
                CarMessage hat = new CarMessage("6", "掘进1", "333", "R0001", "李四");
                redis.StringSet("hat", hat);//序列化以后存入库中
                var model = redis.StringGet<CarMessage>("hat");//反序列化后取值
                Console.WriteLine("hat Key：{0}，Value：{1}", "hat", model.CarNumber);

6、StackExchange.Redis中模糊搜索key的方法

/// <summary>
            /// 模糊搜索keys
            /// </summary>
            /// <param name="pattern">表达式</param>
            public IEnumerable<RedisKey> KeysSearch(string pattern,int dbNum)
            {
                // get the target server
                var server = GetServer(dbNum);
                return server.Keys(pattern: pattern);
            }

这里的参数是key的字符串前缀，第二个参数是使用哪个库，这里只使用0库。

这里的getServer是

public IServer GetServer(int dbNum)
            {
                return _conn.GetServer(_conn.GetEndPoints()[dbNum]);
            }

\_conn是

private readonly ConnectionMultiplexer _conn;

调用示例:

IEnumerable<RedisKey>  keys = redis.KeysSearch(historyPointKeyPrefix+"*",0);

这里的historyPointKeyPrefix是字符串

private string historyPointKeyPrefix = "car:historyPoint:";

对应redis中key的前缀

![57d6cd7641c84dcca4c195dcd7e87c61.png][]

模糊搜索到所有的key之后，对Key的集合进行筛选过滤符合条件的数据。

需要对每个key取到其value，并解析其json字符串为对象，然后根据对象的值

进行筛选。

Redis中每个key的数据格式

![492884b0699a433998b3ea3c3b69028a.png][]

新建对应属性的类

class CarVo
        {
            public string carNumber { get; set; }
            public string carType { get; set; }
            public string cardNumber { get; set; }
            public string flameout { get; set; }
            public string online { get; set; }
            public string vehicleDirection { get; set; }
            public string vehiclePlace { get; set; }
            public string x { get; set; }
            public string y { get; set; }
    
        }

然后筛选条件是分别获取每个value并解析为对象，根据对象的x和y属性判定是否在某个区域内

List<RedisKey> keyList  = keys.Where(key =>
                        {
                            CarVo car = redis.StringGet<CarVo>(key);
                            PointF point = new PointF(Convert.ToSingle(car.x), Convert.ToSingle(car.y));
                            bool result = GisHelper.isPointInPolygon(point, waitingRoomPoints);
                            return result;
                        }
                    ).ToList();

[GitHub - StackExchange_StackExchange.Redis_ General purpose redis client]: https://github.com/StackExchange/StackExchange.Redis
[Basic Usage _ StackExchange.Redis]: https://stackexchange.github.io/StackExchange.Redis/Basics
[CSDN_-C_SpringBoot]: https://blog.csdn.net/badao_liumang_qizhi
[https_www.cnblogs.com_cang12138_p_8884362.html]: https://www.cnblogs.com/cang12138/p/8884362.html
[5a273556765e43059a27b52fbce9d357.png]: https://img-blog.csdnimg.cn/5a273556765e43059a27b52fbce9d357.png
[55ea6010ebbb4238844adc6709e3f7d0.png]: https://img-blog.csdnimg.cn/55ea6010ebbb4238844adc6709e3f7d0.png
[fe7169b56bf44b2abc3acc2d8bc68629.png]: https://img-blog.csdnimg.cn/fe7169b56bf44b2abc3acc2d8bc68629.png
[57d6cd7641c84dcca4c195dcd7e87c61.png]: https://img-blog.csdnimg.cn/57d6cd7641c84dcca4c195dcd7e87c61.png
[492884b0699a433998b3ea3c3b69028a.png]: https://img-blog.csdnimg.cn/492884b0699a433998b3ea3c3b69028a.png