MyRedisHelper帮助类

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

namespace MyUtility.RedisHelper {
    public class MyRedisHelper {
        private IDatabase db;
        public MyRedisHelper(int? DbNum = null) {
            if (DbNum == null) {
                var dbnum = ConfigHelper.GetValue("RedisDbNum");
                DbNum = dbnum == null ? 0 : int.Parse(dbnum);
            }
            db = RedisConnectionHelper.GetDataBase(DbNum);
        }

        public IDatabase GetDatabase() {
            return db;
        }

        #region 同步方法

        #region String
        /// <summary>
        /// 保存单个key vlaue
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">值</param>
        /// <param name="expiry">过期时间</param>
        /// <returns></returns>
        public bool StringSet(string key, string value, TimeSpan? expiry = null) {
            return db.StringSet(key, value, expiry);
        }

        /// <summary>
        /// 保存多个key value
        /// </summary>
        /// <param name="keyValues">KeyValuePair的list</param>
        /// <returns></returns>
        public bool StringSet(List<KeyValuePair<RedisKey, RedisValue>> keyValues) {
            return db.StringSet(keyValues.ToArray());
        }

        /// <summary>
        /// 保存对象到redis
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="key">key</param>
        /// <param name="obj">对象</param>
        /// <param name="expiry">过期时间</param>
        /// <returns></returns>
        public bool StringSet<T>(string key, T obj, TimeSpan? expiry = null) {
            string json = ToJson(obj);
            return db.StringSet(key, json, expiry);
        }

        /// <summary>
        /// 根据key获取value的值
        /// </summary>
        /// <param name="key">key</param>
        /// <returns></returns>
        public string StringGet(string key) {
            if (!db.KeyExists(key)) { return null; }
            return db.StringGet(key);
        }

        /// <summary>
        /// 获取多个key的值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys">key的集合</param>
        /// <returns></returns>
        public RedisValue[] StringGet<T>(List<string> keys) {
            return db.StringGet(ConvertRedisKey(keys));
        }

        /// <summary>
        /// 根据key获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T StringGet<T>(string key) {
            if (!db.KeyExists(key)) { return default(T); }
            var json = db.StringGet(key);
            return ToObject<T>(json);
        }

        /// <summary>
        /// 为数字增长val
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="val">增长的数字可以为负</param>
        /// <returns></returns>
        public double StringIncrement(string key, double val) {
            return db.StringIncrement(key, val);
        }

        /// <summary>
        /// 为数字减少val
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="val">减少的数字可以为负</param>
        /// <returns></returns>
        public double StringDecrement(string key, double val) {
            return db.StringDecrement(key, val);
        }

        #endregion

        #region 分布式锁
        /// <summary>
        /// 对指定的key加锁 key表示的是redis数据库中该锁的名称，不可重复。 value用来标识谁拥有该锁并用来释放锁 可以用Guid()。TimeSpan表示该锁的有效时间。
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public bool LockTake(string key, string value, TimeSpan expiry) {
            return db.LockTake(key, value, expiry);
        }
        #endregion

        #region Hash
        /// <summary>
        /// 判断某个数据是否在此hash表中
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public bool HashExists(string key, string hashField) {
            return db.HashExists(key, hashField);
        }
        /// <summary>
        /// 存储字符串到hash表
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool HashSet(string key, string hashField, string value) {
            return db.HashSet(key, hashField, value);
        }
        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool HashSet<T>(string key, string hashField, T t) {
            string json = ToJson<T>(t);
            return db.HashSet(key, hashField, json);
        }
        /// <summary>
        /// 将HashEntry[]存储数据到hash表
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashEntries"></param>
        /// <param name="expiry"></param>
        public void HashSet(string key, HashEntry[] hashEntries) {
            db.HashSet(key, hashEntries);
        }
        /// <summary>
        /// 将Dictionary存储数据到hash表
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dic"></param>
        /// <param name="expiry"></param>
        public void HashSet(string key, Dictionary<string, string> dic) {
            db.HashSet(key, dic.ToHashEntriesFromDic());
        }
        /// <summary>
        /// 移除hash表中的某个值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public bool HashDelete(string key, string hashField) {
            return db.HashDelete(key, hashField);
        }
        /// <summary>
        /// 移除hash表中的多个值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashFields"></param>
        /// <returns></returns>
        public long HashDelete(string key, List<RedisValue> hashFields) {
            return db.HashDelete(key, hashFields.ToArray());
        }
        /// <summary>
        /// 从hash表中获取指定的hashField值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public string HashGet(string key, string hashField) {
            var value = db.HashGet(key, hashField);
            return value;
        }
        /// <summary>
        ///  从hash表中获取指定的hashField的对象 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public T HashGet<T>(string key, string hashField) {
            var value = db.HashGet(key, hashField);
            return ToObject<T>(value);
        }
        /// <summary>
        /// 从hash表中获取list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> HashGetList<T>(string key) {
            var values = db.HashValues(key);
            List<T> list = new List<T>();
            foreach (var item in values) {
                list.Add(ToObject<T>(item));
            }
            return list;
        }
        /// <summary>
        /// 从hash表中取出所有键值对 返回dic
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public Dictionary<string, string> HashGetDic(string key) {
            var hashEntries = db.HashGetAll(key);
            var dic = hashEntries.ConvertFromRedisToDic();
            return dic;
        }
        /// <summary>
        /// 从hash表中取出所有键值对 返回T类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T HashGetObj<T>(string key) {
            var hashEntries = db.HashGetAll(key);
            T t = hashEntries.ConvertFromRedisToObj<T>();
            return t;
        }
        /// <summary>
        /// 为数字增长val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="val">可以为负</param>
        /// <returns>增长后的值</returns>
        public double HashIncrement(string key, string dataKey, double val = 1) {
            return db.HashIncrement(key, dataKey, val);
        }
        /// <summary>
        /// 为数字减少val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="val">可以为负</param>
        /// <returns>减少后的值</returns>
        public double HashDecrement(string key, string dataKey, double val = 1) {
            return db.HashDecrement(key, dataKey, val);
        }
        /// <summary>
        /// 获取hashkey所有Redis key(hashField)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> HashKeys<T>(string key) {
            var values = db.HashKeys(key);
            List<T> list = new List<T>();
            foreach (var item in values) {
                list.Add(ToObject<T>(item));
            }
            return list;
        }

        #endregion

        #region List
        /// <summary>
        /// 移除指定key的list的内部的值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void ListRemove<T>(string key, T value) {
            db.ListRemove(key, ToJson(value));
        }

        /// <summary>
        /// 获取指定key的List内容
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> ListRange<T>(string key) {
            var values = db.ListRange(key);
            List<T> list = new List<T>();
            foreach (var item in values) {
                list.Add(ToObject<T>(item));
            }
            return list;
        }

        /// <summary>
        /// 入队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void ListRightPush<T>(string key, T value) {
            db.ListRightPush(key, ToJson(value));
        }

        /// <summary>
        /// 出队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T ListRightPop<T>(string key) {
            var value = db.ListRightPop(key);
            return ToObject<T>(value);
        }

        /// <summary>
        /// 入队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void ListLeftPush<T>(string key, T value) {
            db.ListLeftPush(key, ToJson(value));
        }

        /// <summary>
        /// 出队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T ListLeftPop<T>(string key) {
            var value = db.ListLeftPop(key);
            return ToObject<T>(value);
        }

        /// <summary>
        /// 获取list的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long ListLength(string key) {
            return db.ListLength(key);
        }
        #endregion

        #region SortedSet 有序集合
        /// <summary>
        /// 添加到有序集合中
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key">key</param>
        /// <param name="value">值</param>
        /// <param name="score">分数</param>
        /// <returns></returns>
        public bool SortedSetAdd<T>(string key, T value, double score) {
            return db.SortedSetAdd(key, ToJson(value), score);
        }

        /// <summary>
        /// 从有序集合中删除指定的value
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SortedSetRemove<T>(string key, T value) {
            return db.SortedSetRemove(key, ToJson(value));
        }

        /// <summary>
        /// 获取集合的所有数据返回list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> SortedSetRangeByRank<T>(string key) {
            var values = db.SortedSetRangeByRank(key);
            List<T> list = new List<T>();
            foreach (var item in values) {
                list.Add(ToObject<T>(item));
            }
            return list;
        }

        /// <summary>
        /// 获取指定集合的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long SortedSetLength(string key) {
            return db.SortedSetLength(key);
        }
        #endregion

        #region key
        /// <summary>
        /// 删除指定的key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool KeyDelete(string key) {
            return db.KeyDelete(key);
        }

        /// <summary>
        /// 删除多个指定的keys
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public long KeyDelete(List<string> keys) {
            return db.KeyDelete(ConvertRedisKey(keys));
        }

        /// <summary>
        /// 判断指定的key是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool KeyExists(string key) {
            return db.KeyExists(key);
        }

        /// <summary>
        /// 对指定的key进行重新命名为newKey
        /// </summary>
        /// <param name="key">原key</param>
        /// <param name="newKey">新的key</param>
        /// <returns></returns>
        public bool KeyRename(string key, string newKey) {
            return db.KeyRename(key, newKey);
        }

        /// <summary>
        /// 设置key的过期时间
        /// </summary>
        /// <param name="key"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public bool KeyExpire(string key, TimeSpan? expiry) {
            return db.KeyExpire(key, expiry);
        }
        #endregion

        #region 其他
        /// <summary>
        /// 开始使用批量提交打包
        /// </summary>
        public IBatch CreateBatch() {
            return db.CreateBatch();
        }
        #endregion
        #endregion

        #region 异步方法
        #region String
        /// <summary>
        /// 保存单个key vlaue
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">值</param>
        /// <param name="expiry">过期时间</param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync(string key, string value, TimeSpan? expiry = null) {
            return await db.StringSetAsync(key, value, expiry);
        }

        /// <summary>
        /// 保存多个key value
        /// </summary>
        /// <param name="keyValues">KeyValuePair的list</param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync(List<KeyValuePair<RedisKey, RedisValue>> keyValues) {
            return await db.StringSetAsync(keyValues.ToArray());
        }

        /// <summary>
        /// 保存对象到redis
        /// </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 = null) {
            string json = ToJson(obj);
            return await db.StringSetAsync(key, json, expiry);
        }

        /// <summary>
        /// 根据key获取value的值
        /// </summary>
        /// <param name="key">key</param>
        /// <returns></returns>
        public async Task<string> StringGetAsync(string key) {
            if (!db.KeyExists(key)) { return null; }
            return await db.StringGetAsync(key);
        }

        /// <summary>
        /// 获取多个key的值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="keys">key的集合</param>
        /// <returns></returns>
        public async Task<RedisValue[]> StringGetAsync<T>(List<string> keys) {
            return await db.StringGetAsync(ConvertRedisKey(keys));
        }

        /// <summary>
        /// 根据key获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> StringGetAsync<T>(string key) {
            if (!db.KeyExists(key)) { return default(T); }
            var json = await db.StringGetAsync(key);
            return ToObject<T>(json);
        }

        /// <summary>
        /// 为数字增长val
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="val">增长的数字可以为负</param>
        /// <returns></returns>
        public async Task<double> StringIncrementAsync(string key, double val) {
            return await db.StringIncrementAsync(key, val);
        }

        /// <summary>
        /// 为数字减少val
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="val">减少的数字可以为负</param>
        /// <returns></returns>
        public async Task<double> StringDecrementAsync(string key, double val) {
            return await db.StringDecrementAsync(key, val);
        }

        #endregion

        #region 分布式锁
        /// <summary>
        /// 对指定的key加锁 key表示的是redis数据库中该锁的名称，不可重复。 value用来标识谁拥有该锁并用来释放锁 可以用Guid()。TimeSpan表示该锁的有效时间。
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public async Task<bool> LockTakeAsync(string key, string value, TimeSpan expiry) {
            return await db.LockTakeAsync(key, value, expiry);
        }
        #endregion

        #region Hash
        /// <summary>
        /// 判断某个数据是否在此hash表中
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public async Task<bool> HashExistsAsync(string key, string hashField) {
            return await db.HashExistsAsync(key, hashField);
        }
        /// <summary>
        /// 存储字符串到hash表
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<bool> HashSetAsync(string key, string hashField, string value) {
            return await db.HashSetAsync(key, hashField, value);
        }
        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public async Task<bool> HashSetAsync<T>(string key, string hashField, T t) {
            string json = ToJson<T>(t);
            return await db.HashSetAsync(key, hashField, json);
        }
        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashEntries"></param>
        public async Task HashSetAsync(string key, HashEntry[] hashEntries) {
            await db.HashSetAsync(key, hashEntries);
        }
        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dic"></param>
        /// <returns></returns>
        public async Task HashSetAsync(string key, Dictionary<string, string> dic) {
            await db.HashSetAsync(key, dic.ToHashEntriesFromDic());
        }
        /// <summary>
        /// 移除hash表中的某个值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public async Task<bool> HashDeleteAsync(string key, string hashField) {
            return await db.HashDeleteAsync(key, hashField);
        }
        /// <summary>
        /// 移除hash表中的多个值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashFields"></param>
        /// <returns></returns>
        public async Task<long> HashDeleteAsync(string key, List<RedisValue> hashFields) {
            return await db.HashDeleteAsync(key, hashFields.ToArray());
        }
        /// <summary>
        /// 从hash表中获取指定的hashField值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public async Task<string> HashGetAsync(string key, string hashField) {
            var value = await db.HashGetAsync(key, hashField);
            return value;
        }
        /// <summary>
        ///  从hash表中获取指定的hashField的对象 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public async Task<T> HashGetAsync<T>(string key, string hashField) {
            var value = await db.HashGetAsync(key, hashField);
            return ToObject<T>(value);
        }
        /// <summary>
        /// 从hash表中获取list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<List<T>> HashGetListAsync<T>(string key) {
            var values = await db.HashValuesAsync(key);
            List<T> list = new List<T>();
            foreach (var item in values) {
                list.Add(ToObject<T>(item));
            }
            return list;
        }
        /// <summary>
        /// 从hash表中取出所有键值对 返回dic
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<Dictionary<string, string>> HashGetDicAsync(string key) {
            var hashEntries = await db.HashGetAllAsync(key);
            var dic = hashEntries.ConvertFromRedisToDic();
            return dic;
        }
        /// <summary>
        /// 从hash表中取出所有键值对 返回T类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> HashGetObjAsync<T>(string key) {
            var hashEntries = await db.HashGetAllAsync(key);
            T t = hashEntries.ConvertFromRedisToObj<T>();
            return t;
        }
        /// <summary>
        /// 为数字增长val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="val">可以为负</param>
        /// <returns>增长后的值</returns>
        public async Task<double> HashIncrementAsync(string key, string dataKey, double val = 1) {
            return await db.HashIncrementAsync(key, dataKey, val);
        }
        /// <summary>
        /// 为数字减少val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="val">可以为负</param>
        /// <returns>减少后的值</returns>
        public async Task<double> HashDecrementAsync(string key, string dataKey, double val = 1) {
            return await db.HashDecrementAsync(key, dataKey, val);
        }
        /// <summary>
        /// 获取hashkey所有Redis key(hashField)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<List<T>> HashKeysAsync<T>(string key) {
            var values = await db.HashKeysAsync(key);
            List<T> list = new List<T>();
            foreach (var item in values) {
                list.Add(ToObject<T>(item));
            }
            return list;
        }
        #endregion

        #region List
        /// <summary>
        /// 移除指定key的list的内部的值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public async Task<long> ListRemoveAsync<T>(string key, T value) {
            return await db.ListRemoveAsync(key, ToJson(value));
        }

        /// <summary>
        /// 获取指定key的List内容
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<List<T>> ListRangeAsync<T>(string key) {
            var values = await db.ListRangeAsync(key);
            List<T> list = new List<T>();
            foreach (var item in values) {
                list.Add(ToObject<T>(item));
            }
            return list;
        }

        /// <summary>
        /// 入队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public async Task<long> ListRightPushAsync<T>(string key, T value) {
            return await db.ListRightPushAsync(key, ToJson(value));
        }

        /// <summary>
        /// 出队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> ListRightPopAsync<T>(string key) {
            var value = await db.ListRightPopAsync(key);
            return ToObject<T>(value);
        }

        /// <summary>
        /// 入队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public async Task<long> ListLeftPushAsync<T>(string key, T value) {
            return await db.ListLeftPushAsync(key, ToJson(value));
        }

        /// <summary>
        /// 出队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> ListLeftPopAsync<T>(string key) {
            var value = await db.ListLeftPopAsync(key);
            return ToObject<T>(value);
        }

        /// <summary>
        /// 获取list的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<long> ListLengthAsync(string key) {
            return await db.ListLengthAsync(key);
        }
        #endregion

        #region SortedSet 有序集合
        /// <summary>
        /// 添加到有序集合中
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key">key</param>
        /// <param name="value">值</param>
        /// <param name="score">分数</param>
        /// <returns></returns>
        public async Task<bool> SortedSetAddAsync<T>(string key, T value, double score) {
            return await db.SortedSetAddAsync(key, ToJson(value), score);
        }

        /// <summary>
        /// 从有序集合中删除指定的value
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task<bool> SortedSetRemoveAsync<T>(string key, T value) {
            return await db.SortedSetRemoveAsync(key, ToJson(value));
        }

        /// <summary>
        /// 获取集合的所有数据返回list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<List<T>> SortedSetRangeByRankAsync<T>(string key) {
            var values = await db.SortedSetRangeByRankAsync(key);
            List<T> list = new List<T>();
            foreach (var item in values) {
                list.Add(ToObject<T>(item));
            }
            return list;
        }

        /// <summary>
        /// 获取指定集合的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<long> SortedSetLengthAsync(string key) {
            return await db.SortedSetLengthAsync(key);
        }
        #endregion

        #region key
        /// <summary>
        /// 删除指定的key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<bool> KeyDeleteAsync(string key) {
            return await db.KeyDeleteAsync(key);
        }

        /// <summary>
        /// 删除多个指定的keys
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public async Task<long> KeyDeleteAsync(List<string> keys) {
            return await db.KeyDeleteAsync(ConvertRedisKey(keys));
        }

        /// <summary>
        /// 判断指定的key是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<bool> KeyExistsAsync(string key) {
            return await db.KeyExistsAsync(key);
        }

        /// <summary>
        /// 对指定的key进行重新命名为newKey
        /// </summary>
        /// <param name="key">原key</param>
        /// <param name="newKey">新的key</param>
        /// <returns></returns>
        public async Task<bool> KeyRenameAsync(string key, string newKey) {
            return await db.KeyRenameAsync(key, newKey);
        }

        /// <summary>
        /// 设置key的过期时间
        /// </summary>
        /// <param name="key"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public async Task<bool> KeyExpireAsync(string key, TimeSpan? expiry) {
            return await db.KeyExpireAsync(key, expiry);
        }
        #endregion
        #endregion

        #region 辅助方法
        /// <summary>
        /// 序列化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        private string ToJson<T>(T obj) {
            return JsonConvert.SerializeObject(obj);
        }
        /// <summary>
        /// 反序列化返回object
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        private T ToObject<T>(string json) {
            return JsonConvert.DeserializeObject<T>(json);
        }

        /// <summary>
        /// 将集合转化为RedisKey数组
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        RedisKey[] ConvertRedisKey(List<string> keys) {
            return keys.Select(b => (RedisKey)b).ToArray();
        }
        #endregion
    }
}

RedisHelperExtend

using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;

namespace MyUtility.RedisHelper {
    public static class RedisHelperExtend {
        /// <summary>
        /// 将实体类转为HashEntry数组
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static HashEntry[] ToHashEntriesFromObj(this object obj) {
            PropertyInfo[] properties = obj.GetType().GetProperties();
            return properties.Select(propertype =>
                                 new HashEntry(propertype.Name, propertype.GetValue(obj).ToString()))
                             .ToArray();
        }

        /// <summary>
        /// 将HashEntry数组转化为实体类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="hashEntries"></param>
        /// <returns></returns>
        public static T ConvertFromRedisToObj<T>(this HashEntry[] hashEntries) {
            PropertyInfo[] properties = typeof(T).GetProperties();
            var obj = Activator.CreateInstance(typeof(T));
            foreach (var property in properties) {
                HashEntry entry = hashEntries.FirstOrDefault(g => g.Name.ToString().Equals(property.Name));
                if (entry.Equals(new HashEntry())) { continue; }
                property.SetValue(obj, Convert.ChangeType(entry.Value.ToString(), property.PropertyType));
            }
            return (T)obj;
        }

        /// <summary>
        /// 将字典的KeyValue的数据转成HashEntry 字典可以通过来查询list.Select(b =>b).ToDictionary(k=>k.key,v=>v.value);
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static HashEntry[] ToHashEntriesFromDic(this Dictionary<string,string> list) {
            return list.Select(b => new HashEntry(
                b.Key,
                b.Value
                )).ToArray();
        }

        /// <summary>
        /// 将HashEntry数组转化为Dictionary
        /// </summary>
        /// <param name="hashEntries"></param>
        /// <returns></returns>
        public static Dictionary<string, string> ConvertFromRedisToDic(this HashEntry[] hashEntries) {
            return hashEntries.Select(b => b).ToDictionary(
                k => k.Name.ToString(),
                v => v.Value.ToString()
                );
        }
    }
}