cmm123123

博客园 首页 联系 订阅 管理
.net Redis工具类

新建RedisCache缓存类库 

 

 代码如下：

RedisHelper：

  1 using FBW.RedisCache.Service;
  2 using Newtonsoft.Json;
  3 using StackExchange.Redis;
  4 using System;
  5 using System.Collections.Generic;
  6 using System.Linq;
  7 using System.Text;
  8 using System.Threading.Tasks;
  9 
 10 namespace FBW.RedisCache
 11 {
 12     public abstract class RedisHelper
 13     {
 14 
 15         #region 属性字段
 16         /// <summary>
 17         /// 网站Redis 系统自定义Key前缀
 18         /// </summary>
 19         protected string CustomKey = RedisManager.RedisSysCustomKey;
 20         /// <summary>
 21         /// 网站Redis 链接字符串
 22         /// </summary>
 23         protected readonly ConnectionMultiplexer _conn;
 24         /// <summary>
 25         /// Redis操作对象
 26         /// </summary>
 27         protected readonly IDatabase redis = null;
 28         #endregion
 29 
 30         #region 构造函数
 31         /// <summary>
 32         /// 初始化Redis操作方法基础类
 33         /// </summary>
 34         /// <param name="dbNum">操作的数据库索引0-64(需要在conf文件中配置)</param>
 35         protected RedisHelper(int? dbNum = null)
 36         {
 37             _conn = RedisManager.Instance;
 38             if (_conn != null)
 39             {
 40                 redis = _conn.GetDatabase(dbNum ?? RedisManager.RedisDataBaseIndex);
 41             }
 42             else
 43             {
 44                throw new ArgumentNullException("Redis连接初始化失败");
 45             }
 46         }
 47         #endregion 构造函数
 48 
 49         #region 外部调用静态方法
 50         /// <summary>
 51         /// 获取Redis的String数据类型操作辅助方法类
 52         /// </summary>
 53         /// <returns></returns>
 54         public static RedisStringService StringService => new RedisStringService();
 55         /// <summary>
 56         /// 获取Redis的Hash数据类型操作辅助方法类
 57         /// </summary>
 58         /// <returns></returns>
 59         public static RedisHashService HashService => new RedisHashService();
 60         /// <summary>
 61         /// 获取Redis的List数据类型操作辅助方法类
 62         /// </summary>
 63         /// <returns></returns>
 64         public static RedisListService ListService => new RedisListService();
 65         /// <summary>
 66         /// 获取Redis的Set无序集合数据类型操作辅助方法类
 67         /// </summary>
 68         /// <returns></returns>
 69         public static RedisSetService SetService => new RedisSetService();
 70         /// <summary>
 71         /// 获取Redis的SortedSet(ZSet)有序集合数据类型操作辅助方法类
 72         /// </summary>
 73         /// <returns></returns>
 74         public static RedisSortedSetService SortedSetService => new RedisSortedSetService(); 
 75 
 76 
 77 
 78         #endregion
 79 
 80         #region 公共操作方法
 81 
 82         #region 不建议公开这些方法，如果项目中用不到，建议注释或者删除
 83         /// <summary>
 84         /// 获取Redis事务对象
 85         /// </summary>
 86         /// <returns></returns>
 87         public ITransaction CreateTransaction() => redis.CreateTransaction();
 88 
 89         /// <summary>
 90         /// 获取Redis服务和常用操作对象
 91         /// </summary>
 92         /// <returns></returns>
 93         public IDatabase GetDatabase() => redis;
 94 
 95         /// <summary>
 96         /// 获取Redis服务
 97         /// </summary>
 98         /// <param name="hostAndPort"></param>
 99         /// <returns></returns>
100         public IServer GetServer(string hostAndPort) => _conn.GetServer(hostAndPort);
101 
102         /// <summary>
103         /// 执行Redis事务
104         /// </summary>
105         /// <param name="act"></param>
106         /// <returns></returns>
107         public bool RedisTransaction(Action<ITransaction> act)
108         {
109             var tran = redis.CreateTransaction();
110             act.Invoke(tran);
111             bool committed = tran.Execute();
112             return committed;
113         }
114         /// <summary>
115         /// Redis锁
116         /// </summary>
117         /// <param name="act"></param>
118         /// <param name="ts">锁住时间</param>
119         public void RedisLockTake(Action act, TimeSpan ts)
120         {
121             RedisValue token = Environment.MachineName;
122             string lockKey = "lock_LockTake";
123             if (redis.LockTake(lockKey, token, ts))
124             {
125                 try
126                 {
127                     act();
128                 }
129                 finally
130                 {
131                     redis.LockRelease(lockKey, token);
132                 }
133             }
134         }
135         #endregion 其他
136 
137         #region 常用Key操作
138         /// <summary>
139         /// 设置前缀
140         /// </summary>
141         /// <param name="customKey"></param>
142         public void SetSysCustomKey(string customKey) => CustomKey = customKey;
143 
144         /// <summary>
145         /// 组合缓存Key名称
146         /// </summary>
147         /// <param name="oldKey"></param>
148         /// <returns></returns>
149         public string AddSysCustomKey(string oldKey) => $"{CustomKey}_{oldKey}";
150 
151         #region 同步方法
152 
153         /// <summary>
154         /// 删除单个key
155         /// </summary>
156         /// <param name="key">要删除的key</param>
157         /// <returns>是否删除成功</returns>
158         public bool KeyDelete(string key)
159         {
160             key = AddSysCustomKey(key);
161             return redis.KeyDelete(key);
162         }
163 
164         /// <summary>
165         /// 删除多个key
166         /// </summary>
167         /// <param name="keys">要删除的key集合</param>
168         /// <returns>成功删除的个数</returns>
169         public long KeyDelete(params string[] keys)
170         {
171             RedisKey[] newKeys = keys.Select(o => (RedisKey)AddSysCustomKey(o)).ToArray();
172             return redis.KeyDelete(newKeys);
173         }
174 
175         /// <summary>
176         /// 清空当前DataBase中所有Key
177         /// </summary>
178         public void KeyFulsh()
179         {
180             //直接执行清除命令
181             redis.Execute("FLUSHDB");
182         }
183 
184         /// <summary>
185         /// 判断key是否存在
186         /// </summary>
187         /// <param name="key">要判断的key</param>
188         /// <returns></returns>
189         public bool KeyExists(string key)
190         {
191             key = AddSysCustomKey(key);
192             return redis.KeyExists(key);
193         }
194 
195         /// <summary>
196         /// 重新命名key
197         /// </summary>
198         /// <param name="key">就的redis key</param>
199         /// <param name="newKey">新的redis key</param>
200         /// <returns></returns>
201         public bool KeyRename(string key, string newKey)
202         {
203             key = AddSysCustomKey(key);
204             newKey = AddSysCustomKey(newKey);
205             return redis.KeyRename(key, newKey);
206         }
207 
208         /// <summary>
209         /// 设置Key的过期时间
210         /// </summary>
211         /// <param name="key">redis key</param>
212         /// <param name="expiry">过期时间</param>
213         /// <returns></returns>
214         public bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
215         {
216             key = AddSysCustomKey(key);
217             return redis.KeyExpire(key, expiry);
218         }
219 
220 
221         #endregion
222 
223         #region 异步方法
224 
225         /// <summary>
226         /// 删除单个key
227         /// </summary>
228         /// <param name="key">要删除的key</param>
229         /// <returns>是否删除成功</returns>
230         public async Task<bool> KeyDeleteAsync(string key)
231         {
232             key = AddSysCustomKey(key);
233             return await redis.KeyDeleteAsync(key);
234         }
235 
236         /// <summary>
237         /// 删除多个key
238         /// </summary>
239         /// <param name="keys">要删除的key集合</param>
240         /// <returns>成功删除的个数</returns>
241         public async Task<long> KeyDeleteAsync(params string[] keys)
242         {
243             RedisKey[] newKeys = keys.Select(o => (RedisKey)AddSysCustomKey(o)).ToArray();
244             return await redis.KeyDeleteAsync(newKeys);
245         }
246 
247         /// <summary>
248         /// 清空当前DataBase中所有Key
249         /// </summary>
250         public async Task KeyFulshAsync()
251         {
252             //直接执行清除命令
253             await redis.ExecuteAsync("FLUSHDB");
254         }
255 
256         /// <summary>
257         /// 判断key是否存在
258         /// </summary>
259         /// <param name="key">要判断的key</param>
260         /// <returns></returns>
261         public async Task<bool> KeyExistsAsync(string key)
262         {
263             key = AddSysCustomKey(key);
264             return await redis.KeyExistsAsync(key);
265         }
266 
267         /// <summary>
268         /// 重新命名key
269         /// </summary>
270         /// <param name="key">就的redis key</param>
271         /// <param name="newKey">新的redis key</param>
272         /// <returns></returns>
273         public async Task<bool> KeyRenameAsync(string key, string newKey)
274         {
275             key = AddSysCustomKey(key);
276             newKey = AddSysCustomKey(newKey);
277             return await redis.KeyRenameAsync(key, newKey);
278         }
279 
280         /// <summary>
281         /// 设置Key的过期时间
282         /// </summary>
283         /// <param name="key">redis key</param>
284         /// <param name="expiry">过期时间</param>
285         /// <returns></returns>
286         public async Task<bool> KeyExpireAsync(string key, TimeSpan? expiry = default(TimeSpan?))
287         {
288             key = AddSysCustomKey(key);
289             return await redis.KeyExpireAsync(key, expiry);
290         }
291         #endregion
292 
293         #endregion 
294 
295         #endregion
296 
297         #region 辅助方法
298 
299         /// <summary>
300         /// 将对象转换成string字符串
301         /// </summary>
302         /// <typeparam name="T"></typeparam>
303         /// <param name="value"></param>
304         /// <returns></returns>
305         protected string ConvertJson<T>(T value)
306         {
307             string result = value is string ? value.ToString() :
308                 JsonConvert.SerializeObject(value, Formatting.None);
309             return result;
310         }
311         /// <summary>
312         /// 将值反系列化成对象
313         /// </summary>
314         /// <typeparam name="T"></typeparam>
315         /// <param name="value"></param>
316         /// <returns></returns>
317         protected T ConvertObj<T>(RedisValue value)
318         {
319             return value.IsNullOrEmpty ? default(T) : JsonConvert.DeserializeObject<T>(value);
320         }
321 
322         /// <summary>
323         /// 将值反系列化成对象集合
324         /// </summary>
325         /// <typeparam name="T"></typeparam>
326         /// <param name="values"></param>
327         /// <returns></returns>
328         protected List<T> ConvetList<T>(RedisValue[] values)
329         {
330             List<T> result = new List<T>();
331             foreach (var item in values)
332             {
333                 var model = ConvertObj<T>(item);
334                 result.Add(model);
335             }
336             return result;
337         }
338         /// <summary>
339         /// 将string类型的Key转换成 <see cref="RedisKey"/> 型的Key
340         /// </summary>
341         /// <param name="redisKeys"></param>
342         /// <returns></returns>
343         protected RedisKey[] ConvertRedisKeys(List<string> redisKeys) => redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
344 
345         /// <summary>
346         /// 将string类型的Key转换成 <see cref="RedisKey"/> 型的Key
347         /// </summary>
348         /// <param name="redisKeys"></param>
349         /// <returns></returns>
350         protected RedisKey[] ConvertRedisKeys(params string[] redisKeys) => redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
351 
352         /// <summary>
353         /// 将string类型的Key转换成 <see cref="RedisKey"/> 型的Key，并添加前缀字符串
354         /// </summary>
355         /// <param name="redisKeys"></param>
356         /// <returns></returns>
357         protected RedisKey[] ConvertRedisKeysAddSysCustomKey(params string[] redisKeys) => redisKeys.Select(redisKey => (RedisKey)AddSysCustomKey(redisKey)).ToArray();
358         /// <summary>
359         /// 将值集合转换成RedisValue集合
360         /// </summary>
361         /// <typeparam name="T"></typeparam>
362         /// <param name="redisValues"></param>
363         /// <returns></returns>
364         protected RedisValue[] ConvertRedisValue<T>(params T[] redisValues) => redisValues.Select(o => (RedisValue)ConvertJson<T>(o)).ToArray();
365         #endregion 辅助方法
366 
367     }
368 }
View Code

RedisManager:

  1 using StackExchange.Redis;
  2 using System;
  3 using System.Collections.Concurrent;
  4 using System.Collections.Generic;
  5 using System.Configuration;
  6 using System.Linq;
  7 using System.Text;
  8 using System.Threading.Tasks;
  9 
 10 namespace FBW.RedisCache
 11 { /// <summary>
 12   /// Redis基本信息初始化辅助类
 13   /// </summary>
 14     internal class RedisManager
 15     {
 16         //private static LogHelper log = LogHelper.LogInterface<RedisManager>();
 17         private static readonly object Locker = new object();
 18         private static ConnectionMultiplexer _instance;
 19         private static readonly ConcurrentDictionary<string, ConnectionMultiplexer> ConnectionCache = new ConcurrentDictionary<string, ConnectionMultiplexer>();
 20         ///// <summary>
 21         ///// Redis保存的Key前缀，会自动添加到指定的Key名称前
 22         ///// </summary>
 23         internal static readonly string RedisSysCustomKey = "FBW";
 24         ///// <summary>
 25         ///// 当前连接的Redis中的DataBase索引，默认0-16，可以在service.conf配置，最高64
 26         ///// </summary>
 27         internal static readonly int RedisDataBaseIndex = 0;
 28         /// <summary>
 29         /// 当前连接的Redis中连接字符串，格式为：127.0.0.1:6379,allowadmin=true,passowrd=pwd
 30         /// </summary>
 31         internal static readonly string RedisHostConnection = ConfigurationManager.AppSettings["RedisDbConStr"];
 32 
 33         /// <summary>
 34         /// 单例获取
 35         /// </summary>
 36         public static ConnectionMultiplexer Instance
 37         {
 38             get
 39             {
 40                 if (_instance == null)
 41                 {
 42                     lock (Locker)
 43                     {
 44                         if (_instance == null || !_instance.IsConnected)
 45                         {
 46                             _instance = GetManager();
 47                         }
 48                     }
 49                 }
 50                 return _instance;
 51             }
 52         }
 53 
 54         /// <summary>
 55         /// 缓存获取
 56         /// </summary>
 57         /// <param name="connectionString"></param>
 58         /// <returns></returns>
 59         public static ConnectionMultiplexer GetConnectionMultiplexer(string connectionString)
 60         {
 61             if (!ConnectionCache.ContainsKey(connectionString))
 62             {
 63                 ConnectionCache[connectionString] = GetManager(connectionString);
 64             }
 65             return ConnectionCache[connectionString];
 66         }
 67 
 68         /// <summary>
 69         /// 内部方法，获取Redis连接
 70         /// </summary>
 71         /// <param name="connectionString"></param>
 72         /// <returns></returns>
 73         private static ConnectionMultiplexer GetManager(string connectionString = null)
 74         {
 75             connectionString = connectionString ?? RedisHostConnection;
 76             var connect = ConnectionMultiplexer.Connect(connectionString);
 77 
 78             //注册如下事件
 79             connect.ConnectionFailed += MuxerConnectionFailed;
 80             connect.ConnectionRestored += MuxerConnectionRestored;
 81             connect.ErrorMessage += MuxerErrorMessage;
 82             connect.ConfigurationChanged += MuxerConfigurationChanged;
 83             connect.HashSlotMoved += MuxerHashSlotMoved;
 84             connect.InternalError += MuxerInternalError;
 85 
 86             return connect;
 87         }
 88 
 89         #region 事件
 90 
 91         /// <summary>
 92         /// 配置更改时
 93         /// </summary>
 94         /// <param name="sender"></param>
 95         /// <param name="e"></param>
 96         private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
 97         {
 98             //log.InfoAsync($"Configuration changed: {e.EndPoint}");
 99         }
100 
101         /// <summary>
102         /// 发生错误时
103         /// </summary>
104         /// <param name="sender"></param>
105         /// <param name="e"></param>
106         private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
107         {
108             //log.InfoAsync($"ErrorMessage: {e.Message}");
109         }
110 
111         /// <summary>
112         /// 重新建立连接之前的错误
113         /// </summary>
114         /// <param name="sender"></param>
115         /// <param name="e"></param>
116         private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
117         {
118             //log.InfoAsync($"ConnectionRestored: {e.EndPoint}");
119         }
120 
121         /// <summary>
122         /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
123         /// </summary>
124         /// <param name="sender"></param>
125         /// <param name="e"></param>
126         private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
127         {
128             //log.InfoAsync($"重新连接：Endpoint failed: {e.EndPoint},  {e.FailureType} , {(e.Exception == null ? "" : e.Exception.Message)}");
129         }
130 
131         /// <summary>
132         /// 更改集群
133         /// </summary>
134         /// <param name="sender"></param>
135         /// <param name="e"></param>
136         private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
137         {
138             //log.InfoAsync($"HashSlotMoved:NewEndPoint{e.NewEndPoint}, OldEndPoint{e.OldEndPoint}");
139         }
140 
141         /// <summary>
142         /// redis类库错误
143         /// </summary>
144         /// <param name="sender"></param>
145         /// <param name="e"></param>
146         private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
147         {
148             //log.InfoAsync($"InternalError:Message{ e.Exception.Message}");
149         }
150 
151         #endregion 事件
152     }
153 }
View Code

RedisHashService:

  1 using StackExchange.Redis;
  2 using System;
  3 using System.Collections.Generic;
  4 using System.Linq;
  5 using System.Text;
  6 using System.Threading.Tasks;
  7 
  8 namespace FBW.RedisCache.Service
  9 {
 10     /// <summary>
 11     /// Hash:类似dictionary，通过索引快速定位到指定元素的，耗时均等，跟string的区别在于不用反序列化，直接修改某个字段
 12     /// string的话要么是 001:序列化整个实体
 13     ///           要么是 001_name:  001_pwd: 多个key-value
 14     /// Hash的话，一个hashid-{key:value;key:value;key:value;}
 15     /// 可以一次性查找实体，也可以单个，还可以单个修改
 16     /// </summary>
 17     public class RedisHashService : RedisHelper
 18     {
 19 
 20         #region 构造函数
 21 
 22         /// <summary>
 23         /// 初始化Redis的Hash数据结构操作
 24         /// </summary>
 25         /// <param name="dbNum">操作的数据库索引0-64(需要在conf文件中配置)</param>
 26         public RedisHashService(int? dbNum = null) :
 27             base(dbNum)
 28         { }
 29         #endregion
 30 
 31         #region 同步方法
 32 
 33         /// <summary>
 34         /// 判断某个数据是否已经被缓存
 35         /// </summary>
 36         /// <param name="key"></param>
 37         /// <param name="dataKey"></param>
 38         /// <returns></returns>
 39         public bool HashExists(string key, string dataKey)
 40         {
 41             key = AddSysCustomKey(key);
 42             return base.redis.HashExists(key, dataKey);
 43         }
 44 
 45         /// <summary>
 46         /// 存储数据到hash表
 47         /// </summary>
 48         /// <typeparam name="T"></typeparam>
 49         /// <param name="key"></param>
 50         /// <param name="dataKey"></param>
 51         /// <param name="t"></param>
 52         /// <returns></returns>
 53         public bool HashSet<T>(string key, string dataKey, T t)
 54         {
 55             key = AddSysCustomKey(key);
 56             string json = ConvertJson(t);
 57             return base.redis.HashSet(key, dataKey, json);
 58         }
 59 
 60         /// <summary>
 61         /// 移除hash中的某值
 62         /// </summary>
 63         /// <param name="key"></param>
 64         /// <param name="dataKey"></param>
 65         /// <returns></returns>
 66         public bool HashDelete(string key, string dataKey)
 67         {
 68             key = AddSysCustomKey(key);
 69             return base.redis.HashDelete(key, dataKey);
 70         }
 71 
 72         /// <summary>
 73         /// 移除hash中的多个值
 74         /// </summary>
 75         /// <param name="key"></param>
 76         /// <param name="dataKeys"></param>
 77         /// <returns></returns>
 78         public long HashDelete(string key, params string[] dataKeys)
 79         {
 80             key = AddSysCustomKey(key);
 81             var newValues = dataKeys.Select(o => (RedisValue)o).ToArray();
 82             return base.redis.HashDelete(key, newValues);
 83         }
 84 
 85         /// <summary>
 86         /// 从hash表获取数据
 87         /// </summary>
 88         /// <typeparam name="T"></typeparam>
 89         /// <param name="key"></param>
 90         /// <param name="dataKey"></param>
 91         /// <returns></returns>
 92         public T HashGet<T>(string key, string dataKey)
 93         {
 94             key = AddSysCustomKey(key);
 95             string value = base.redis.HashGet(key, dataKey);
 96             return ConvertObj<T>(value);
 97         }
 98 
 99         /// <summary>
100         /// 数字增长val，返回自增后的值
101         /// </summary>
102         /// <param name="key"></param>
103         /// <param name="dataKey"></param>
104         /// <param name="val">可以为负</param>
105         /// <returns>增长后的值</returns>
106         public double HashIncrement(string key, string dataKey, double val = 1)
107         {
108             key = AddSysCustomKey(key);
109             return base.redis.HashIncrement(key, dataKey, val);
110         }
111 
112         /// <summary>
113         /// 数字减少val，返回自减少的值
114         /// </summary>
115         /// <param name="key"></param>
116         /// <param name="dataKey"></param>
117         /// <param name="val">可以为负</param>
118         /// <returns>减少后的值</returns>
119         public double HashDecrement(string key, string dataKey, double val = 1)
120         {
121             key = AddSysCustomKey(key);
122             return base.redis.HashDecrement(key, dataKey, val);
123         }
124 
125         /// <summary>
126         /// 获取hashkey所有key名称
127         /// </summary>
128         /// <param name="key"></param>
129         /// <returns></returns>
130         public string[] HashKeys(string key)
131         {
132             key = AddSysCustomKey(key);
133             RedisValue[] values = base.redis.HashKeys(key);
134             return values.Select(o => o.ToString()).ToArray();
135         }
136 
137         /// <summary>
138         /// 获取hashkey所有key与值，必须保证Key内的所有数据类型一致
139         /// </summary>
140         /// <typeparam name="T"></typeparam>
141         /// <param name="key"></param>
142         /// <returns></returns>
143         public Dictionary<string, T> HashGetAll<T>(string key)
144         {
145             key = AddSysCustomKey(key);
146             var query = base.redis.HashGetAll(key);
147             Dictionary<string, T> dic = new Dictionary<string, T>();
148             foreach (var item in query)
149             {
150                 dic.Add(item.Name, ConvertObj<T>(item.Value));
151             }
152             return dic;
153         }
154 
155         #endregion 同步方法
156 
157         #region 异步方法
158 
159         /// <summary>
160         /// 异步方法 判断某个数据是否已经被缓存
161         /// </summary>
162         /// <param name="key"></param>
163         /// <param name="dataKey"></param>
164         /// <returns></returns>
165         public async Task<bool> HashExistsAsync(string key, string dataKey)
166         {
167             key = AddSysCustomKey(key);
168             return await base.redis.HashExistsAsync(key, dataKey);
169         }
170 
171         /// <summary>
172         /// 异步方法 存储数据到hash表
173         /// </summary>
174         /// <typeparam name="T"></typeparam>
175         /// <param name="key"></param>
176         /// <param name="dataKey"></param>
177         /// <param name="t"></param>
178         /// <returns></returns>
179         public async Task<bool> HashSetAsync<T>(string key, string dataKey, T t)
180         {
181             key = AddSysCustomKey(key);
182             string json = ConvertJson(t);
183             return await base.redis.HashSetAsync(key, dataKey, json);
184         }
185 
186         /// <summary>
187         /// 异步方法 移除hash中的某值
188         /// </summary>
189         /// <param name="key"></param>
190         /// <param name="dataKey"></param>
191         /// <returns></returns>
192         public async Task<bool> HashDeleteAsync(string key, string dataKey)
193         {
194             key = AddSysCustomKey(key);
195             return await base.redis.HashDeleteAsync(key, dataKey);
196         }
197 
198         /// <summary>
199         /// 异步方法 移除hash中的多个值
200         /// </summary>
201         /// <param name="key"></param>
202         /// <param name="dataKeys"></param>
203         /// <returns></returns>
204         public async Task<long> HashDeleteAsync(string key, params string[] dataKeys)
205         {
206             key = AddSysCustomKey(key);
207             var newValues = dataKeys.Select(o => (RedisValue)o).ToArray();
208             return await base.redis.HashDeleteAsync(key, newValues);
209         }
210 
211         /// <summary>
212         /// 异步方法 从hash表获取数据
213         /// </summary>
214         /// <typeparam name="T"></typeparam>
215         /// <param name="key"></param>
216         /// <param name="dataKey"></param>
217         /// <returns></returns>
218         public async Task<T> HashGetAsync<T>(string key, string dataKey)
219         {
220             key = AddSysCustomKey(key);
221             string value = await base.redis.HashGetAsync(key, dataKey);
222             return ConvertObj<T>(value);
223         }
224 
225         /// <summary>
226         /// 异步方法 数字增长val，返回自增后的值
227         /// </summary>
228         /// <param name="key"></param>
229         /// <param name="dataKey"></param>
230         /// <param name="val">可以为负</param>
231         /// <returns>增长后的值</returns>
232         public async Task<double> HashIncrementAsync(string key, string dataKey, double val = 1)
233         {
234             key = AddSysCustomKey(key);
235             return await base.redis.HashIncrementAsync(key, dataKey, val);
236         }
237 
238         /// <summary>
239         /// 异步方法 数字减少val，返回自减少的值
240         /// </summary>
241         /// <param name="key"></param>
242         /// <param name="dataKey"></param>
243         /// <param name="val">可以为负</param>
244         /// <returns>减少后的值</returns>
245         public async Task<double> HashDecrementAsync(string key, string dataKey, double val = 1)
246         {
247             key = AddSysCustomKey(key);
248             return await base.redis.HashDecrementAsync(key, dataKey, val);
249         }
250 
251         /// <summary>
252         /// 异步方法 获取hashkey所有key名称
253         /// </summary>
254         /// <param name="key"></param>
255         /// <returns></returns>
256         public async Task<string[]> HashKeysAsync(string key)
257         {
258             key = AddSysCustomKey(key);
259             RedisValue[] values = await base.redis.HashKeysAsync(key);
260             return values.Select(o => o.ToString()).ToArray();
261         }
262 
263         /// <summary>
264         /// 获取hashkey所有key与值，必须保证Key内的所有数据类型一致
265         /// </summary>
266         /// <typeparam name="T"></typeparam>
267         /// <param name="key"></param>
268         /// <returns></returns>
269         public async Task<Dictionary<string, T>> HashGetAllAsync<T>(string key)
270         {
271             key = AddSysCustomKey(key);
272             var query = await base.redis.HashGetAllAsync(key);
273             Dictionary<string, T> dic = new Dictionary<string, T>();
274             foreach (var item in query)
275             {
276                 dic.Add(item.Name, ConvertObj<T>(item.Value));
277             }
278             return dic;
279         }
280 
281         #endregion 异步方法
282 
283     }
284 }
View Code

RedisListService:

using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FBW.RedisCache.Service
{

    /// <summary>
    /// Redis list的实现为一个双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销，
    /// Redis内部的很多实现，包括发送缓冲队列等也都是用的这个数据结构。  
    /// 一般是左进右出或者右进左出 
    /// </summary>
    public class RedisListService :RedisHelper
    {
        #region 构造函数

        /// <summary>
        /// 初始化Redis的List数据结构操作
        /// </summary>
        /// <param name="dbNum">操作的数据库索引0-64(需要在conf文件中配置)</param>
        public RedisListService(int? dbNum = null) :
            base(dbNum)
        { }
        #endregion

        #region 同步方法
        /// <summary>
        /// 从左侧向list中添加一个值，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public long ListLeftPush<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return base.redis.ListLeftPush(key, jValue);
        }

        /// <summary>
        /// 从左侧向list中添加多个值，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public long ListLeftPush<T>(string key, List<T> value)
        {
            key = AddSysCustomKey(key);
            RedisValue[] valueList = base.ConvertRedisValue(value.ToArray());
            return base.redis.ListLeftPush(key, valueList);
        }

        /// <summary>
        /// 从右侧向list中添加一个值，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public long ListRightPush<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return base.redis.ListRightPush(key, jValue);
        }

        /// <summary>
        /// 从右侧向list中添加多个值，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public long ListRightPush<T>(string key, List<T> value)
        {
            key = AddSysCustomKey(key);
            RedisValue[] valueList = base.ConvertRedisValue(value.ToArray());
            return base.redis.ListRightPush(key, valueList);
        }

        /// <summary>
        /// 从左侧向list中取出一个值并从list中删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T ListLeftPop<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = base.redis.ListLeftPop(key);
            return base.ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 从右侧向list中取出一个值并从list中删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T ListRightPop<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = base.redis.ListRightPop(key);
            return base.ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 从key的List中右侧取出一个值，并从左侧添加到destination集合中，且返回该数据对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key">要取出数据的List名称</param>
        /// <param name="destination">要添加到的List名称</param>
        /// <returns></returns>
        public T ListRightPopLeftPush<T>(string key, string destination)
        {
            key = AddSysCustomKey(key);
            destination = AddSysCustomKey(destination);
            var rValue = base.redis.ListRightPopLeftPush(key, destination);
            return base.ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 在key的List指定值pivot之后插入value，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="pivot">索引值</param>
        /// <param name="value">要插入的值</param>
        /// <returns></returns>
        public long ListInsertAfter<T>(string key, T pivot, T value)
        {
            key = AddSysCustomKey(key);
            string pValue = ConvertJson(pivot);
            string jValue = ConvertJson(value);
            return base.redis.ListInsertAfter(key, pValue, jValue);
        }

        /// <summary>
        /// 在key的List指定值pivot之前插入value，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="pivot">索引值</param>
        /// <param name="value">要插入的值</param>
        /// <returns></returns>
        public long ListInsertBefore<T>(string key, T pivot, T value)
        {
            key = AddSysCustomKey(key);
            string pValue = ConvertJson(pivot);
            string jValue = ConvertJson(value);
            return base.redis.ListInsertBefore(key, pValue, jValue);
        }

        /// <summary>
        /// 从key的list中取出所有数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> ListRange<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = base.redis.ListRange(key);
            return base.ConvetList<T>(rValue);
        }

        /// <summary>
        /// 从key的List获取指定索引的值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public T ListGetByIndex<T>(string key, long index)
        {
            key = AddSysCustomKey(key);
            var rValue = base.redis.ListGetByIndex(key, index);
            return base.ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 获取key的list中数据个数
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long ListLength(string key)
        {
            key = AddSysCustomKey(key);
            return base.redis.ListLength(key);
        }

        /// <summary>
        /// 从key的List中移除指定的值，返回删除个数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public long ListRemove<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return base.redis.ListRemove(key, jValue);
        }
        #endregion

        #region 异步方法
        /// <summary>
        /// 从左侧向list中添加一个值，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<long> ListLeftPushAsync<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return await base.redis.ListLeftPushAsync(key, jValue);
        }

        /// <summary>
        /// 从左侧向list中添加多个值，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<long> ListLeftPushAsync<T>(string key, List<T> value)
        {
            key = AddSysCustomKey(key);
            RedisValue[] valueList = base.ConvertRedisValue(value.ToArray());
            return await base.redis.ListLeftPushAsync(key, valueList);
        }

        /// <summary>
        /// 从右侧向list中添加一个值，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<long> ListRightPushAsync<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return await base.redis.ListRightPushAsync(key, jValue);
        }

        /// <summary>
        /// 从右侧向list中添加多个值，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<long> ListRightPushAsync<T>(string key, List<T> value)
        {
            key = AddSysCustomKey(key);
            RedisValue[] valueList = base.ConvertRedisValue(value.ToArray());
            return await base.redis.ListRightPushAsync(key, valueList);
        }

        /// <summary>
        /// 从左侧向list中取出一个值并从list中删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> ListLeftPopAsync<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = await base.redis.ListLeftPopAsync(key);
            return base.ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 从右侧向list中取出一个值并从list中删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> ListRightPopAsync<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = await base.redis.ListRightPopAsync(key);
            return base.ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 从key的List中右侧取出一个值，并从左侧添加到destination集合中，且返回该数据对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key">要取出数据的List名称</param>
        /// <param name="destination">要添加到的List名称</param>
        /// <returns></returns>
        public async Task<T> ListRightPopLeftPushAsync<T>(string key, string destination)
        {
            key = AddSysCustomKey(key);
            destination = AddSysCustomKey(destination);
            var rValue = await base.redis.ListRightPopLeftPushAsync(key, destination);
            return base.ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 在key的List指定值pivot之后插入value，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="pivot">索引值</param>
        /// <param name="value">要插入的值</param>
        /// <returns></returns>
        public async Task<long> ListInsertAfterAsync<T>(string key, T pivot, T value)
        {
            key = AddSysCustomKey(key);
            string pValue = ConvertJson(pivot);
            string jValue = ConvertJson(value);
            return await base.redis.ListInsertAfterAsync(key, pValue, jValue);
        }

        /// <summary>
        /// 在key的List指定值pivot之前插入value，返回集合总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="pivot">索引值</param>
        /// <param name="value">要插入的值</param>
        /// <returns></returns>
        public async Task<long> ListInsertBeforeAsync<T>(string key, T pivot, T value)
        {
            key = AddSysCustomKey(key);
            string pValue = ConvertJson(pivot);
            string jValue = ConvertJson(value);
            return await base.redis.ListInsertBeforeAsync(key, pValue, jValue);
        }

        /// <summary>
        /// 从key的list中取出所有数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<List<T>> ListRangeAsync<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = await base.redis.ListRangeAsync(key);
            return base.ConvetList<T>(rValue);
        }

        /// <summary>
        /// 从key的List获取指定索引的值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public async Task<T> ListGetByIndexAsync<T>(string key, long index)
        {
            key = AddSysCustomKey(key);
            var rValue = await base.redis.ListGetByIndexAsync(key, index);
            return base.ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 获取key的list中数据个数
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<long> ListLengthAsync(string key)
        {
            key = AddSysCustomKey(key);
            return await base.redis.ListLengthAsync(key);
        }

        /// <summary>
        /// 从key的List中移除指定的值，返回删除个数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<long> ListRemoveAsync<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return await base.redis.ListRemoveAsync(key, jValue);
        }
        #endregion
    }
}
View Code

RedisSetService:

using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FBW.RedisCache.Service
{ /// <summary>
  /// Set：用哈希表来保持字符串的唯一性，没有先后顺序，存储一些集合性的数据
  /// 1.共同好友、二度好友
  /// 2.利用唯一性，可以统计访问网站的所有独立 IP
  /// </summary>
    public class RedisSetService :RedisHelper
    {
        #region 构造函数

        /// <summary>
        /// 初始化Redis的Set无序数据结构操作
        /// </summary>
        /// <param name="dbNum">操作的数据库索引0-64(需要在conf文件中配置)</param>
        public RedisSetService(int? dbNum = null) :
            base(dbNum)
        { }
        #endregion

        #region 同步方法
        /// <summary>
        /// 在Key集合中添加一个value值
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="key">Key名称</param>
        /// <param name="value">值</param>
        /// <returns></returns>
        public bool SetAdd<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return base.redis.SetAdd(key, jValue);
        }
        /// <summary>
        /// 在Key集合中添加多个value值
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="key">Key名称</param>
        /// <param name="value">值列表</param>
        /// <returns></returns>
        public long SetAdd<T>(string key, List<T> value)
        {
            key = AddSysCustomKey(key);
            RedisValue[] valueList = base.ConvertRedisValue(value.ToArray());
            return base.redis.SetAdd(key, valueList);
        }

        /// <summary>
        /// 获取key集合值的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long SetLength(string key)
        {
            key = AddSysCustomKey(key);
            return base.redis.SetLength(key);
        }

        /// <summary>
        /// 判断Key集合中是否包含指定的值
        /// </summary>
        /// <typeparam name="T">值类型</typeparam>
        /// <param name="key"></param>
        /// <param name="value">要判断是值</param>
        /// <returns></returns>
        public bool SetContains<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return base.redis.SetContains(key, jValue);
        }

        /// <summary>
        /// 随机获取key集合中的一个值
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T SetRandomMember<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = base.redis.SetRandomMember(key);
            return ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 获取key所有值的集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> SetMembers<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = base.redis.SetMembers(key);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 删除key集合中指定的value
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public long SetRemove<T>(string key, params T[] value)
        {
            key = AddSysCustomKey(key);
            RedisValue[] valueList = base.ConvertRedisValue(value);
            return base.redis.SetRemove(key, valueList);
        }

        /// <summary>
        /// 随机删除key集合中的一个值，并返回该值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T SetPop<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = base.redis.SetPop(key);
            return ConvertObj<T>(rValue);
        }


        /// <summary>
        /// 获取几个集合的并集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public List<T> SetCombineUnion<T>(params string[] keys)
        {
            return _SetCombine<T>(SetOperation.Union, keys);
        }
        /// <summary>
        /// 获取几个集合的交集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public List<T> SetCombineIntersect<T>(params string[] keys)
        {
            return _SetCombine<T>(SetOperation.Intersect, keys);
        }
        /// <summary>
        /// 获取几个集合的差集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public List<T> SetCombineDifference<T>(params string[] keys)
        {
            return _SetCombine<T>(SetOperation.Difference, keys);
        }

        /// <summary>
        /// 获取几个集合的并集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public long SetCombineUnionAndStore(string destination, params string[] keys)
        {
            return _SetCombineAndStore(SetOperation.Union, destination, keys);
        }
        /// <summary>
        /// 获取几个集合的交集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public long SetCombineIntersectAndStore(string destination, params string[] keys)
        {
            return _SetCombineAndStore(SetOperation.Intersect, destination, keys);
        }
        /// <summary>
        /// 获取几个集合的差集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public long SetCombineDifferenceAndStore(string destination, params string[] keys)
        {
            return _SetCombineAndStore(SetOperation.Difference, destination, keys);
        }
       

        #endregion

        #region 异步方法
        /// <summary>
        /// 在Key集合中添加一个value值
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="key">Key名称</param>
        /// <param name="value">值</param>
        /// <returns></returns>
        public async Task<bool> SetAddAsync<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return await base.redis.SetAddAsync(key, jValue);
        }
        /// <summary>
        /// 在Key集合中添加多个value值
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="key">Key名称</param>
        /// <param name="value">值列表</param>
        /// <returns></returns>
        public async Task<long> SetAddAsync<T>(string key, List<T> value)
        {
            key = AddSysCustomKey(key);
            RedisValue[] valueList = base.ConvertRedisValue(value.ToArray());
            return await base.redis.SetAddAsync(key, valueList);
        }

        /// <summary>
        /// 获取key集合值的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<long> SetLengthAsync(string key)
        {
            key = AddSysCustomKey(key);
            return await base.redis.SetLengthAsync(key);
        }

        /// <summary>
        /// 判断Key集合中是否包含指定的值
        /// </summary>
        /// <typeparam name="T">值类型</typeparam>
        /// <param name="key"></param>
        /// <param name="value">要判断是值</param>
        /// <returns></returns>
        public async Task<bool> SetContainsAsync<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jValue = ConvertJson(value);
            return await base.redis.SetContainsAsync(key, jValue);
        }

        /// <summary>
        /// 随机获取key集合中的一个值
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> SetRandomMemberAsync<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = await base.redis.SetRandomMemberAsync(key);
            return ConvertObj<T>(rValue);
        }

        /// <summary>
        /// 获取key所有值的集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<List<T>> SetMembersAsync<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = await base.redis.SetMembersAsync(key);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 删除key集合中指定的value
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<long> SetRemoveAsync<T>(string key, params T[] value)
        {
            key = AddSysCustomKey(key);
            RedisValue[] valueList = base.ConvertRedisValue(value);
            return await base.redis.SetRemoveAsync(key, valueList);
        }

        /// <summary>
        /// 随机删除key集合中的一个值，并返回该值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> SetPopAsync<T>(string key)
        {
            key = AddSysCustomKey(key);
            var rValue = await base.redis.SetPopAsync(key);
            return ConvertObj<T>(rValue);
        }


        /// <summary>
        /// 获取几个集合的并集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public async Task<List<T>> SetCombineUnionAsync<T>(params string[] keys)
        {
            return await _SetCombineAsync<T>(SetOperation.Union, keys);
        }
        /// <summary>
        /// 获取几个集合的交集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public async Task<List<T>> SetCombineIntersectAsync<T>(params string[] keys)
        {
            return await _SetCombineAsync<T>(SetOperation.Intersect, keys);
        }
        /// <summary>
        /// 获取几个集合的差集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public async Task<List<T>> SetCombineDifferenceAsync<T>(params string[] keys)
        {
            return await _SetCombineAsync<T>(SetOperation.Difference, keys);
        }



        /// <summary>
        /// 获取几个集合的并集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public async Task<long> SetCombineUnionAndStoreAsync(string destination, params string[] keys)
        {
            return await _SetCombineAndStoreAsync(SetOperation.Union, destination, keys);
        }
        /// <summary>
        /// 获取几个集合的交集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public async Task<long> SetCombineIntersectAndStoreAsync(string destination, params string[] keys)
        {
            return await _SetCombineAndStoreAsync(SetOperation.Intersect, destination, keys);
        }
        /// <summary>
        /// 获取几个集合的差集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public async Task<long> SetCombineDifferenceAndStoreAsync(string destination, params string[] keys)
        {
            return await _SetCombineAndStoreAsync(SetOperation.Difference, destination, keys);
        }

        #endregion

        #region 内部辅助方法
        /// <summary>
        /// 获取几个集合的交叉并集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="operation">Union：并集  Intersect：交集  Difference：差集  详见 <see cref="SetOperation"/></param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        private List<T> _SetCombine<T>(SetOperation operation, params string[] keys)
        {
            RedisKey[] keyList = base.ConvertRedisKeysAddSysCustomKey(keys);
            var rValue = base.redis.SetCombine(operation, keyList);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 获取几个集合的交叉并集合,并保存到一个新Key中
        /// </summary>
        /// <param name="operation">Union：并集  Intersect：交集  Difference：差集  详见 <see cref="SetOperation"/></param>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        private long _SetCombineAndStore(SetOperation operation, string destination, params string[] keys)
        {
            destination = AddSysCustomKey(destination);
            RedisKey[] keyList = base.ConvertRedisKeysAddSysCustomKey(keys);
            return base.redis.SetCombineAndStore(operation, destination, keyList);
        }
        /// <summary>
        /// 获取几个集合的交叉并集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="operation">Union：并集  Intersect：交集  Difference：差集  详见 <see cref="SetOperation"/></param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        private async Task<List<T>> _SetCombineAsync<T>(SetOperation operation, params string[] keys)
        {
            RedisKey[] keyList = base.ConvertRedisKeysAddSysCustomKey(keys);
            var rValue = await base.redis.SetCombineAsync(operation, keyList);
            return ConvetList<T>(rValue);
        }
        /// <summary>
        /// 获取几个集合的交叉并集合,并保存到一个新Key中
        /// </summary>
        /// <param name="operation">Union：并集  Intersect：交集  Difference：差集  详见 <see cref="SetOperation"/></param>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        private async Task<long> _SetCombineAndStoreAsync(SetOperation operation, string destination, params string[] keys)
        {
            destination = AddSysCustomKey(destination);
            RedisKey[] keyList = base.ConvertRedisKeysAddSysCustomKey(keys);
            return await base.redis.SetCombineAndStoreAsync(operation, destination, keyList);
        }

        #endregion

    }
}
View Code

RedisSortedSetService:

using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FBW.RedisCache.Service
{
    /// <summary>
    /// Sorted Sets是将 Set 中的元素增加了一个权重参数 score，使得集合中的元素能够按 score 进行有序排列
    /// 1.带有权重的元素，比如一个游戏的用户得分排行榜
    /// 2.比较复杂的数据结构，一般用到的场景不算太多
    /// </summary>
    public class RedisSortedSetService : RedisHelper
    {
        #region 构造函数

        /// <summary>
        /// 初始化Redis的SortedSet有序数据结构操作
        /// </summary>
        /// <param name="dbNum">操作的数据库索引0-64(需要在conf文件中配置)</param>
        public RedisSortedSetService(int? dbNum = null) :
            base(dbNum)
        { }
        #endregion

        #region 同步方法

        /// <summary>
        /// 添加一个值到Key
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="score">排序分数，为空将获取集合中最大score加1</param>
        /// <returns></returns>
        public bool SortedSetAdd<T>(string key, T value, double? score = null)
        {
            key = AddSysCustomKey(key);
            double scoreNum = score ?? _GetScore(key);
            return base.redis.SortedSetAdd(key, ConvertJson<T>(value), scoreNum);
        }

        /// <summary>
        /// 添加一个集合到Key
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="score">排序分数，为空将获取集合中最大score加1</param>
        /// <returns></returns>
        public long SortedSetAdd<T>(string key, List<T> value, double? score = null)
        {
            key = AddSysCustomKey(key);
            double scoreNum = score ?? _GetScore(key);
            SortedSetEntry[] rValue = value.Select(o => new SortedSetEntry(ConvertJson<T>(o), scoreNum++)).ToArray();
            return base.redis.SortedSetAdd(key, rValue);
        }

        /// <summary>
        /// 获取集合中的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long SortedSetLength(string key)
        {
            key = AddSysCustomKey(key);
            return redis.SortedSetLength(key);
        }

        /// <summary>
        /// 获取指定起始值到结束值的集合数量
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="startValue">起始值</param>
        /// <param name="endValue">结束值</param>
        /// <returns></returns>
        public long SortedSetLengthByValue<T>(string key, T startValue, T endValue)
        {
            key = AddSysCustomKey(key);
            var sValue = ConvertJson<T>(startValue);
            var eValue = ConvertJson<T>(endValue);
            return redis.SortedSetLengthByValue(key, sValue, eValue);
        }

        /// <summary>
        /// 获取指定Key的排序Score值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public double? SortedSetScore<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            var rValue = ConvertJson<T>(value);
            return redis.SortedSetScore(key, rValue);
        }

        /// <summary>
        /// 获取指定Key中最小Score值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public double SortedSetMinScore(string key)
        {
            key = AddSysCustomKey(key);
            double dValue = 0;
            var rValue = base.redis.SortedSetRangeByRankWithScores(key, 0, 0, Order.Ascending).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue;
        }

        /// <summary>
        /// 获取指定Key中最大Score值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public double SortedSetMaxScore(string key)
        {
            key = AddSysCustomKey(key);
            double dValue = 0;
            var rValue = base.redis.SortedSetRangeByRankWithScores(key, 0, 0, Order.Descending).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue;
        }

        /// <summary>
        /// 删除Key中指定的值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public long SortedSetRemove<T>(string key, params T[] value)
        {
            key = AddSysCustomKey(key);
            var rValue = ConvertRedisValue<T>(value);
            return base.redis.SortedSetRemove(key, rValue);
        }

        /// <summary>
        /// 删除指定起始值到结束值的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="startValue">起始值</param>
        /// <param name="endValue">结束值</param>
        /// <returns></returns>
        public long SortedSetRemoveRangeByValue<T>(string key, T startValue, T endValue)
        {
            key = AddSysCustomKey(key);
            var sValue = ConvertJson<T>(startValue);
            var eValue = ConvertJson<T>(endValue);
            return base.redis.SortedSetRemoveRangeByValue(key, sValue, eValue);
        }

        /// <summary>
        /// 删除 从 start 开始的 stop 条数据
        /// </summary>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        public long SortedSetRemoveRangeByRank(string key, long start, long stop)
        {
            key = AddSysCustomKey(key);
            return base.redis.SortedSetRemoveRangeByRank(key, start, stop);
        }

        /// <summary>
        /// 根据排序分数Score，删除从 start 开始的 stop 条数据
        /// </summary>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        public long SortedSetRemoveRangeByScore(string key, double start, double stop)
        {
            key = AddSysCustomKey(key);
            return base.redis.SortedSetRemoveRangeByScore(key, start, stop);
        }

        /// <summary>
        /// 获取从 start 开始的 stop 条数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start">起始数</param>
        /// <param name="stop">-1表示到结束，0为1条</param>
        /// <param name="desc">是否按降序排列</param>
        /// <returns></returns>
        public List<T> SortedSetRangeByRank<T>(string key, long start = 0, long stop = -1, bool desc = false)
        {
            key = AddSysCustomKey(key);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = base.redis.SortedSetRangeByRank(key, start, stop, orderBy);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 获取从 start 开始的 stop 条数据包含Score，返回数据格式：Key=值，Value = Score
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start">起始数</param>
        /// <param name="stop">-1表示到结束，0为1条</param>
        /// <param name="desc">是否按降序排列</param>
        /// <returns></returns>
        public Dictionary<T, double> SortedSetRangeByRankWithScores<T>(string key, long start = 0, long stop = -1, bool desc = false)
        {
            key = AddSysCustomKey(key);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = base.redis.SortedSetRangeByRankWithScores(key, start, stop, orderBy);
            Dictionary<T, double> dicList = new Dictionary<T, double>();
            foreach (var item in rValue)
            {
                dicList.Add(ConvertObj<T>(item.Element), item.Score);
            }
            return dicList;
        }

        /// <summary>
        ///  根据Score排序 获取从 start 开始的 stop 条数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start">起始数</param>
        /// <param name="stop">-1表示到结束，0为1条</param>
        /// <param name="desc">是否按降序排列</param>
        /// <returns></returns>
        public List<T> SortedSetRangeByScore<T>(string key, double start = 0, double stop = -1, bool desc = false)
        {
            key = AddSysCustomKey(key);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = base.redis.SortedSetRangeByScore(key, start, stop, Exclude.None, orderBy);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 根据Score排序  获取从 start 开始的 stop 条数据包含Score，返回数据格式：Key=值，Value = Score
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start">起始数</param>
        /// <param name="stop">-1表示到结束，0为1条</param>
        /// <param name="desc">是否按降序排列</param>
        /// <returns></returns>
        public Dictionary<T, double> SortedSetRangeByScoreWithScores<T>(string key, double start = 0, double stop = -1, bool desc = false)
        {
            key = AddSysCustomKey(key);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = base.redis.SortedSetRangeByScoreWithScores(key, start, stop, Exclude.None, orderBy);
            Dictionary<T, double> dicList = new Dictionary<T, double>();
            foreach (var item in rValue)
            {
                dicList.Add(ConvertObj<T>(item.Element), item.Score);
            }
            return dicList;
        }

        /// <summary>
        /// 获取指定起始值到结束值的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="startValue">起始值</param>
        /// <param name="endValue">结束值</param>
        /// <returns></returns>
        public List<T> SortedSetRangeByValue<T>(string key, T startValue, T endValue)
        {
            key = AddSysCustomKey(key);
            var sValue = ConvertJson<T>(startValue);
            var eValue = ConvertJson<T>(endValue);
            var rValue = base.redis.SortedSetRangeByValue(key, sValue, eValue);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 获取几个集合的并集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public long SortedSetCombineUnionAndStore(string destination, params string[] keys)
        {
            return _SortedSetCombineAndStore(SetOperation.Union, destination, keys);
        }

        /// <summary>
        /// 获取几个集合的交集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public long SortedSetCombineIntersectAndStore(string destination, params string[] keys)
        {
            return _SortedSetCombineAndStore(SetOperation.Intersect, destination, keys);
        }


        //交集似乎并不支持
        ///// <summary>
        ///// 获取几个集合的差集,并保存到一个新Key中
        ///// </summary>
        ///// <param name="destination">保存的新Key名称</param>
        ///// <param name="keys">要操作的Key集合</param>
        ///// <returns></returns>
        //public long SortedSetCombineDifferenceAndStore(string destination, params string[] keys)
        //{
        //    return _SortedSetCombineAndStore(SetOperation.Difference, destination, keys);
        //}



        /// <summary>
        /// 修改指定Key和值的Scores在原值上减去scores，并返回最终Scores
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="scores"></param>
        /// <returns></returns>
        public double SortedSetDecrement<T>(string key, T value, double scores)
        {
            key = AddSysCustomKey(key);
            var rValue = ConvertJson<T>(value);
            return redis.SortedSetDecrement(key, rValue, scores);
        }

        /// <summary>
        /// 修改指定Key和值的Scores在原值上增加scores，并返回最终Scores
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="scores"></param>
        /// <returns></returns>
        public double SortedSetIncrement<T>(string key, T value, double scores)
        {
            key = AddSysCustomKey(key);
            var rValue = ConvertJson<T>(value);
            return redis.SortedSetIncrement(key, rValue, scores);
        }



        #endregion

        #region 异步方法

        /// <summary>
        /// 添加一个值到Key
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="score">排序分数，为空将获取集合中最大score加1</param>
        /// <returns></returns>
        public async Task<bool> SortedSetAddAsync<T>(string key, T value, double? score = null)
        {
            key = AddSysCustomKey(key);
            double scoreNum = score ?? _GetScore(key);
            return await base.redis.SortedSetAddAsync(key, ConvertJson<T>(value), scoreNum);
        }

        /// <summary>
        /// 添加一个集合到Key
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="score">排序分数，为空将获取集合中最大score加1</param>
        /// <returns></returns>
        public async Task<long> SortedSetAddAsync<T>(string key, List<T> value, double? score = null)
        {
            key = AddSysCustomKey(key);
            double scoreNum = score ?? _GetScore(key);
            SortedSetEntry[] rValue = value.Select(o => new SortedSetEntry(ConvertJson<T>(o), scoreNum++)).ToArray();
            return await base.redis.SortedSetAddAsync(key, rValue);
        }

        /// <summary>
        /// 获取集合中的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<long> SortedSetLengthAsync(string key)
        {
            key = AddSysCustomKey(key);
            return await redis.SortedSetLengthAsync(key);
        }

        /// <summary>
        /// 获取指定起始值到结束值的集合数量
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="startValue">起始值</param>
        /// <param name="endValue">结束值</param>
        /// <returns></returns>
        public async Task<long> SortedSetLengthByValueAsync<T>(string key, T startValue, T endValue)
        {
            key = AddSysCustomKey(key);
            var sValue = ConvertJson<T>(startValue);
            var eValue = ConvertJson<T>(endValue);
            return await redis.SortedSetLengthByValueAsync(key, sValue, eValue);
        }

        /// <summary>
        /// 获取指定Key的排序Score值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<double?> SortedSetScoreAsync<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            var rValue = ConvertJson<T>(value);
            return await redis.SortedSetScoreAsync(key, rValue);
        }

        /// <summary>
        /// 获取指定Key中最小Score值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<double> SortedSetMinScoreAsync(string key)
        {
            key = AddSysCustomKey(key);
            double dValue = 0;
            var rValue = (await base.redis.SortedSetRangeByRankWithScoresAsync(key, 0, 0, Order.Ascending)).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue;
        }

        /// <summary>
        /// 获取指定Key中最大Score值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<double> SortedSetMaxScoreAsync(string key)
        {
            key = AddSysCustomKey(key);
            double dValue = 0;
            var rValue = (await base.redis.SortedSetRangeByRankWithScoresAsync(key, 0, 0, Order.Descending)).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue;
        }

        /// <summary>
        /// 删除Key中指定的值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public async Task<long> SortedSetRemoveAsync<T>(string key, params T[] value)
        {
            key = AddSysCustomKey(key);
            var rValue = ConvertRedisValue<T>(value);
            return await base.redis.SortedSetRemoveAsync(key, rValue);
        }

        /// <summary>
        /// 删除指定起始值到结束值的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="startValue">起始值</param>
        /// <param name="endValue">结束值</param>
        /// <returns></returns>
        public async Task<long> SortedSetRemoveRangeByValueAsync<T>(string key, T startValue, T endValue)
        {
            key = AddSysCustomKey(key);
            var sValue = ConvertJson<T>(startValue);
            var eValue = ConvertJson<T>(endValue);
            return await base.redis.SortedSetRemoveRangeByValueAsync(key, sValue, eValue);
        }

        /// <summary>
        /// 删除 从 start 开始的 stop 条数据
        /// </summary>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        public async Task<long> SortedSetRemoveRangeByRankAsync(string key, long start, long stop)
        {
            key = AddSysCustomKey(key);
            return await base.redis.SortedSetRemoveRangeByRankAsync(key, start, stop);
        }

        /// <summary>
        /// 根据排序分数Score，删除从 start 开始的 stop 条数据
        /// </summary>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        public async Task<long> SortedSetRemoveRangeByScoreAsync(string key, double start, double stop)
        {
            key = AddSysCustomKey(key);
            return await base.redis.SortedSetRemoveRangeByScoreAsync(key, start, stop);
        }

        /// <summary>
        /// 获取从 start 开始的 stop 条数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start">起始数</param>
        /// <param name="stop">-1表示到结束，0为1条</param>
        /// <param name="desc">是否按降序排列</param>
        /// <returns></returns>
        public async Task<List<T>> SortedSetRangeByRankAsync<T>(string key, long start = 0, long stop = -1, bool desc = false)
        {
            key = AddSysCustomKey(key);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = await base.redis.SortedSetRangeByRankAsync(key, start, stop, orderBy);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 获取从 start 开始的 stop 条数据包含Score，返回数据格式：Key=值，Value = Score
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start">起始数</param>
        /// <param name="stop">-1表示到结束，0为1条</param>
        /// <param name="desc">是否按降序排列</param>
        /// <returns></returns>
        public async Task<Dictionary<T, double>> SortedSetRangeByRankWithScoresAsync<T>(string key, long start = 0, long stop = -1, bool desc = false)
        {
            key = AddSysCustomKey(key);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = await base.redis.SortedSetRangeByRankWithScoresAsync(key, start, stop, orderBy);
            Dictionary<T, double> dicList = new Dictionary<T, double>();
            foreach (var item in rValue)
            {
                dicList.Add(ConvertObj<T>(item.Element), item.Score);
            }
            return dicList;
        }

        /// <summary>
        ///  根据Score排序 获取从 start 开始的 stop 条数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start">起始数</param>
        /// <param name="stop">-1表示到结束，0为1条</param>
        /// <param name="desc">是否按降序排列</param>
        /// <returns></returns>
        public async Task<List<T>> SortedSetRangeByScoreAsync<T>(string key, double start = 0, double stop = -1, bool desc = false)
        {
            key = AddSysCustomKey(key);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = await base.redis.SortedSetRangeByScoreAsync(key, start, stop, Exclude.None, orderBy);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 根据Score排序  获取从 start 开始的 stop 条数据包含Score，返回数据格式：Key=值，Value = Score
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start">起始数</param>
        /// <param name="stop">-1表示到结束，0为1条</param>
        /// <param name="desc">是否按降序排列</param>
        /// <returns></returns>
        public async Task<Dictionary<T, double>> SortedSetRangeByScoreWithScoresAsync<T>(string key, double start = 0, double stop = -1, bool desc = false)
        {
            key = AddSysCustomKey(key);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = await base.redis.SortedSetRangeByScoreWithScoresAsync(key, start, stop, Exclude.None, orderBy);
            Dictionary<T, double> dicList = new Dictionary<T, double>();
            foreach (var item in rValue)
            {
                dicList.Add(ConvertObj<T>(item.Element), item.Score);
            }
            return dicList;
        }

        /// <summary>
        /// 获取指定起始值到结束值的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="startValue">起始值</param>
        /// <param name="endValue">结束值</param>
        /// <returns></returns>
        public async Task<List<T>> SortedSetRangeByValueAsync<T>(string key, T startValue, T endValue)
        {
            key = AddSysCustomKey(key);
            var sValue = ConvertJson<T>(startValue);
            var eValue = ConvertJson<T>(endValue);
            var rValue = await base.redis.SortedSetRangeByValueAsync(key, sValue, eValue);
            return ConvetList<T>(rValue);
        }

        /// <summary>
        /// 获取几个集合的并集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public async Task<long> SortedSetCombineUnionAndStoreAsync(string destination, params string[] keys)
        {
            return await _SortedSetCombineAndStoreAsync(SetOperation.Union, destination, keys);
        }

        /// <summary>
        /// 获取几个集合的交集,并保存到一个新Key中
        /// </summary>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        public async Task<long> SortedSetCombineIntersectAndStoreAsync(string destination, params string[] keys)
        {
            return await _SortedSetCombineAndStoreAsync(SetOperation.Intersect, destination, keys);
        }

        ///// <summary>
        ///// 获取几个集合的差集,并保存到一个新Key中
        ///// </summary>
        ///// <param name="destination">保存的新Key名称</param>
        ///// <param name="keys">要操作的Key集合</param>
        ///// <returns></returns>
        //public async Task<long> SortedSetCombineDifferenceAndStoreAsync(string destination, params string[] keys)
        //{
        //    return await _SortedSetCombineAndStoreAsync(SetOperation.Difference, destination, keys);
        //}

        /// <summary>
        /// 修改指定Key和值的Scores在原值上减去scores，并返回最终Scores
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="scores"></param>
        /// <returns></returns>
        public async Task<double> SortedSetDecrementAsync<T>(string key, T value, double scores)
        {
            key = AddSysCustomKey(key);
            var rValue = ConvertJson<T>(value);
            return await base.redis.SortedSetDecrementAsync(key, rValue, scores);
        }

        /// <summary>
        /// 修改指定Key和值的Scores在原值上增加scores，并返回最终Scores
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="scores"></param>
        /// <returns></returns>
        public async Task<double> SortedSetIncrementAsync<T>(string key, T value, double scores)
        {
            key = AddSysCustomKey(key);
            var rValue = ConvertJson<T>(value);
            return await base.redis.SortedSetIncrementAsync(key, rValue, scores);
        }



        #endregion

        #region 内部辅助方法
        /// <summary>
        /// 获取指定Key中最大Score值,
        /// </summary>
        /// <param name="key">key名称，注意要先添加上Key前缀</param>
        /// <returns></returns>
        private double _GetScore(string key)
        {
            double dValue = 0;
            var rValue = base.redis.SortedSetRangeByRankWithScores(key, 0, 0, Order.Descending).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue + 1;
        }

        /// <summary>
        /// 获取几个集合的交叉并集合,并保存到一个新Key中
        /// </summary>
        /// <param name="operation">Union：并集  Intersect：交集  Difference：差集  详见 <see cref="SetOperation"/></param>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        private long _SortedSetCombineAndStore(SetOperation operation, string destination, params string[] keys)
        {
            #region 查看源码，似乎并不支持Difference
            //RedisCommand command;
            //if (operation != SetOperation.Union)
            //{
            //    if (operation != SetOperation.Intersect)
            //    {
            //        throw new ArgumentOutOfRangeException("operation");
            //    }
            //    command = RedisCommand.ZINTERSTORE;
            //}
            //else
            //{
            //    command = RedisCommand.ZUNIONSTORE;
            //}
            #endregion

            destination = AddSysCustomKey(destination);
            RedisKey[] keyList = base.ConvertRedisKeysAddSysCustomKey(keys);
            var rValue = base.redis.SortedSetCombineAndStore(operation, destination, keyList);
            return rValue;

        }

        /// <summary>
        /// 获取几个集合的交叉并集合,并保存到一个新Key中
        /// </summary>
        /// <param name="operation">Union：并集  Intersect：交集  Difference：差集  详见 <see cref="SetOperation"/></param>
        /// <param name="destination">保存的新Key名称</param>
        /// <param name="keys">要操作的Key集合</param>
        /// <returns></returns>
        private async Task<long> _SortedSetCombineAndStoreAsync(SetOperation operation, string destination, params string[] keys)
        {
            destination = AddSysCustomKey(destination);
            RedisKey[] keyList = base.ConvertRedisKeysAddSysCustomKey(keys);
            var rValue = await base.redis.SortedSetCombineAndStoreAsync(operation, destination, keyList);
            return rValue;
        }

        #endregion
    }
}
View Code

RedisStringService:

using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FBW.RedisCache.Service
{
    /// key-value 键值对:value可以是序列化的数据
    /// </summary>
    public class RedisStringService : RedisHelper
    {
        #region 构造函数

        /// <summary>
        /// 初始化Redis的String数据结构操作
        /// </summary>
        /// <param name="dbNum">操作的数据库索引0-64(需要在conf文件中配置)</param>
        public RedisStringService(int? dbNum = null) :
            base(dbNum)
        { }
        #endregion

        #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 base.redis.StringSet(key, value, expiry);
        }

        /// <summary>
        /// 添加多个key/value
        /// </summary>
        /// <param name="valueList">key/value集合</param>
        /// <returns></returns>
        public bool StringSet(Dictionary<string, string> valueList)
        {
            var newkeyValues = valueList.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToArray();
            return base.redis.StringSet(newkeyValues);
        }

        /// <summary>
        /// 保存一个对象
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="key">保存的Key名称</param>
        /// <param name="value">对象实体</param>
        /// <param name="expiry">过期时间</param>
        /// <returns></returns>
        public bool StringSet<T>(string key, T value, TimeSpan? expiry = default(TimeSpan?))
        {
            key = AddSysCustomKey(key);
            string jsonValue = ConvertJson(value);
            return base.redis.StringSet(key, jsonValue, expiry);
        }

        /// <summary>
        /// 在原有key的value值之后追加value
        /// </summary>
        /// <param name="key">追加的Key名称</param>
        /// <param name="value">追加的值</param>
        /// <returns></returns>
        public long StringAppend(string key, string value)
        {
            key = AddSysCustomKey(key);
            return base.redis.StringAppend(key, value);
        }

        /// <summary>
        /// 获取单个key的值
        /// </summary>
        /// <param name="key">要读取的Key名称</param>
        /// <returns></returns>
        public string StringGet(string key)
        {
            key = AddSysCustomKey(key);
            return base.redis.StringGet(key);
        }

        /// <summary>
        /// 获取多个key的value值
        /// </summary>
        /// <param name="keys">要获取值的Key集合</param>
        /// <returns></returns>
        public List<string> StringGet(params string[] keys)
        {
            var newKeys = ConvertRedisKeysAddSysCustomKey(keys);
            var values = base.redis.StringGet(newKeys);
            return values.Select(o => o.ToString()).ToList();
        }


        /// <summary>
        /// 获取单个key的value值
        /// </summary>
        /// <typeparam name="T">返回数据类型</typeparam>
        /// <param name="key">要获取值的Key集合</param>
        /// <returns></returns>
        public T StringGet<T>(string key)
        {
            key = AddSysCustomKey(key);
            var values = base.redis.StringGet(key);
            return ConvertObj<T>(values);
        }

        /// <summary>
        /// 获取多个key的value值
        /// </summary>
        /// <typeparam name="T">返回数据类型</typeparam>
        /// <param name="keys">要获取值的Key集合</param>
        /// <returns></returns>
        public List<T> StringGet<T>(params string[] keys)
        {
            var newKeys = ConvertRedisKeysAddSysCustomKey(keys);
            var values = base.redis.StringGet(newKeys);
            return ConvetList<T>(values);
        }

        /// <summary>
        /// 获取旧值赋上新值
        /// </summary>
        /// <param name="key">Key名称</param>
        /// <param name="value">新值</param>
        /// <returns></returns>
        public string StringGetSet(string key, string value)
        {
            key = AddSysCustomKey(key);
            return base.redis.StringGetSet(key, value);
        }

        /// <summary>
        /// 获取旧值赋上新值
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="key">Key名称</param>
        /// <param name="value">新值</param>
        /// <returns></returns>
        public T StringGetSet<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jsonValue = ConvertJson(value);
            var oValue = base.redis.StringGetSet(key, jsonValue);
            return ConvertObj<T>(oValue);
        }


        /// <summary>
        /// 获取值的长度
        /// </summary>
        /// <param name="key">Key名称</param>
        /// <returns></returns>
        public long StringGetLength(string key)
        {
            key = AddSysCustomKey(key);
            return base.redis.StringLength(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 base.redis.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 base.redis.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 base.redis.StringSetAsync(key, value, expiry);
        }
        /// <summary>
        /// 异步方法 添加多个key/value
        /// </summary>
        /// <param name="valueList">key/value集合</param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync(Dictionary<string, string> valueList)
        {
            var newkeyValues = valueList.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToArray();
            return await base.redis.StringSetAsync(newkeyValues);
        }

        /// <summary>
        /// 异步方法 保存一个对象
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="key">保存的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 jsonValue = ConvertJson(obj);
            return await base.redis.StringSetAsync(key, jsonValue, expiry);
        }

        /// <summary>
        /// 异步方法 在原有key的value值之后追加value
        /// </summary>
        /// <param name="key">追加的Key名称</param>
        /// <param name="value">追加的值</param>
        /// <returns></returns>
        public async Task<long> StringAppendAsync(string key, string value)
        {
            key = AddSysCustomKey(key);
            return await base.redis.StringAppendAsync(key, value);
        }

        /// <summary>
        /// 异步方法 获取单个key的值
        /// </summary>
        /// <param name="key">要读取的Key名称</param>
        /// <returns></returns>
        public async Task<string> StringGetAsync(string key)
        {
            key = AddSysCustomKey(key);
            return await base.redis.StringGetAsync(key);
        }

        /// <summary>
        /// 异步方法 获取多个key的value值
        /// </summary>
        /// <param name="keys">要获取值的Key集合</param>
        /// <returns></returns>
        public async Task<List<string>> StringGetAsync(params string[] keys)
        {
            var newKeys = ConvertRedisKeysAddSysCustomKey(keys);
            var values = await base.redis.StringGetAsync(newKeys);
            return values.Select(o => o.ToString()).ToList();
        }


        /// <summary>
        /// 异步方法 获取单个key的value值
        /// </summary>
        /// <typeparam name="T">返回数据类型</typeparam>
        /// <param name="key">要获取值的Key集合</param>
        /// <returns></returns>
        public async Task<T> StringGetAsync<T>(string key)
        {
            key = AddSysCustomKey(key);
            var values = await base.redis.StringGetAsync(key);
            return ConvertObj<T>(values);
        }

        /// <summary>
        /// 异步方法 获取多个key的value值
        /// </summary>
        /// <typeparam name="T">返回数据类型</typeparam>
        /// <param name="keys">要获取值的Key集合</param>
        /// <returns></returns>
        public async Task<List<T>> StringGetAsync<T>(params string[] keys)
        {
            var newKeys = ConvertRedisKeysAddSysCustomKey(keys);
            var values = await base.redis.StringGetAsync(newKeys);
            return ConvetList<T>(values);
        }

        /// <summary>
        /// 异步方法 获取旧值赋上新值
        /// </summary>
        /// <param name="key">Key名称</param>
        /// <param name="value">新值</param>
        /// <returns></returns>
        public async Task<string> StringGetSetAsync(string key, string value)
        {
            key = AddSysCustomKey(key);
            return await base.redis.StringGetSetAsync(key, value);
        }

        /// <summary>
        /// 异步方法 获取旧值赋上新值
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="key">Key名称</param>
        /// <param name="value">新值</param>
        /// <returns></returns>
        public async Task<T> StringGetSetAsync<T>(string key, T value)
        {
            key = AddSysCustomKey(key);
            string jsonValue = ConvertJson(value);
            var oValue = await base.redis.StringGetSetAsync(key, jsonValue);
            return ConvertObj<T>(oValue);
        }


        /// <summary>
        /// 异步方法 获取值的长度
        /// </summary>
        /// <param name="key">Key名称</param>
        /// <returns></returns>
        public async Task<long> StringGetLengthAsync(string key)
        {
            key = AddSysCustomKey(key);
            return await base.redis.StringLengthAsync(key);
        }

        /// <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 base.redis.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 base.redis.StringDecrementAsync(key, val);
        }

        #endregion
    }
}
View Code

 

posted on 2023-03-24 16:05  95后的码农  阅读(44)  评论(0)  编辑  收藏  举报