using System;
using System.Linq;
using StackExchange.Redis;
using System.Configuration;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Threading.Tasks;
using System.Runtime.Serialization;
using System.Text;

namespace IStation
{
    /// <summary>
    /// Redis客户端辅助类
    /// </summary>
    public class RedisClientHelper
    {

        /// <summary>
        /// redis 连接对象
        /// </summary>
        private static IConnectionMultiplexer _connMultiplexer;

        /// <summary>
        /// 锁
        /// </summary>
        private static readonly object Locker = new object();

        /// <summary>
        /// 数据库访问对象
        /// </summary>
        private readonly IDatabase _db;

        /// <summary>
        /// 采用双重锁单例模式，保证数据访问对象有且仅有一个
        /// </summary>
        /// <returns></returns>
        public IConnectionMultiplexer GetConnectionRedisMultiplexer()
        {
            if ((_connMultiplexer == null || !_connMultiplexer.IsConnected))
            {
                lock (Locker)
                {
                    if ((_connMultiplexer == null || !_connMultiplexer.IsConnected))
                    {
                        _connMultiplexer = ConnectionMultiplexer.Connect(Settings.Redis.Url);
                    }
                }
            }
            return _connMultiplexer;
        }

        /// <summary>
        /// 添加事务处理
        /// </summary>
        /// <returns></returns>
        public ITransaction GetTransaction()
        {
            //创建事务
            return _db.CreateTransaction();
        }

        #region 构造函数
        /// <summary>
        /// 静态的构造函数,
        /// 构造函数是属于类的，而不是属于实例的
        /// 就是说这个构造函数只会被执行一次。也就是在创建第一个实例或引用任何静态成员之前，由.NET自动调用。
        /// </summary>
        static RedisClientHelper()
        {
            _connMultiplexer = ConnectionMultiplexer.Connect(Settings.Redis.Url);
            RegisterEvent();
        }

        /// <summary>
        /// 重载构造器，获取redis内部数据库的交互式连接
        /// </summary>
        /// <param name="db">要获取的数据库ID</param>
        public RedisClientHelper(int db = -1)
        {
            _db = _connMultiplexer.GetDatabase(db);
        }
        #endregion

        #region 通用方法

        /// <summary>
        /// 序列化,用于存储对象
        /// </summary>
        private static byte[] Serialize(object obj)
        {
            try
            {
                if (obj == null)
                    return null;
                var binaryFormatter = new BinaryFormatter();
                using (var memoryStream = new MemoryStream())
                {
                    binaryFormatter.Serialize(memoryStream, obj);
                    var data = memoryStream.ToArray();
                    return data;
                }
            }
            catch (SerializationException ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 反序列化，用于解码对象
        /// </summary>
        private static T Deserialize<T>(byte[] data)
        {
            if (data == null)
                return default(T);
            var binaryFormatter = new BinaryFormatter();
            using (var memoryStream = new MemoryStream(data))
            {
                var result = (T)binaryFormatter.Deserialize(memoryStream);
                return result;
            }
        }

        #endregion

        #region stringGet 

        /// <summary>
        /// 设置key，并保存字符串（如果key 已存在，则覆盖）
        /// </summary>
        public bool StringSet(string redisKey, string redisValue, TimeSpan? expried = null)
        {
            return _db.StringSet(redisKey, redisValue, expried);
        }

        public bool StringSetJson<T>(string redisKey, T redisValue, TimeSpan? expried = null)
        {
            var json = JsonHelper.Object2Json(redisValue);
            return _db.StringSet(redisKey, json, expried);
        }


        /// <summary>
        /// 保存多个key-value
        /// </summary>
        /// <param name="keyValuePairs"></param>
        /// <returns></returns>
        public bool StringSet(IEnumerable<KeyValuePair<RedisKey, RedisValue>> keyValuePairs)
        {
            keyValuePairs =
                keyValuePairs.Select(x => new KeyValuePair<RedisKey, RedisValue>(x.Key, x.Value));
            return _db.StringSet(keyValuePairs.ToArray());
        }

        /// <summary>
        /// 获取字符串
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public RedisValue StringGet(string redisKey)
        {
            try
            {
                return _db.StringGet(redisKey);
            }
            catch (TypeAccessException ex)
            {
                throw ex;
            }
        }

        public T StringGetJson<T>(string redisKey)
        {
            return JsonHelper.Json2Object<T>(_db.StringGet(redisKey));
        }

        /// <summary>
        /// 获取字符串(多个)
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public RedisValue[] StringGet(List<string> redisKey)
        {
            if (redisKey == null || redisKey.Count() == 0)
                return null;

            try
            {
                List<RedisKey> redisKey2 = new List<RedisKey>();
                redisKey.ForEach(t => redisKey2.Add(t));
                return _db.StringGet(redisKey2.ToArray());
            }
            catch (TypeAccessException ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 存储一个对象，该对象会被序列化存储
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public bool StringSet<T>(string redisKey, T redisValue, TimeSpan? expired = null)
        {
            var json = Serialize(redisKey);
            return _db.StringSet(redisKey, json, expired);
        }

        /// <summary>
        /// 获取一个对象(会进行反序列化)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public T StringSet<T>(string redisKey)
        {
            return Deserialize<T>(_db.StringGet(redisKey));
        }

        /// <summary>
        /// 保存一个字符串值
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync(string redisKey, string redisValue, TimeSpan? expired = null)
        {
            return await _db.StringSetAsync(redisKey, redisValue, expired);
        }
        /// <summary>
        /// 保存一个字符串值
        /// </summary>
        /// <param name="keyValuePairs"></param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync(IEnumerable<KeyValuePair<RedisKey, RedisValue>> keyValuePairs)
        {
            if (keyValuePairs == null || keyValuePairs.Count() == 0)
                return false;
            keyValuePairs
                = keyValuePairs.Select(x => new KeyValuePair<RedisKey, RedisValue>(x.Key, x.Value));
            return await _db.StringSetAsync(keyValuePairs.ToArray());
        }
        /// <summary>
        /// 获取单个值
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public async Task<string> StringGetAsync(string redisKey, string redisValue, TimeSpan? expired = null)
        {
            return await _db.StringGetAsync(redisKey);
        }
        /// <summary>
        /// 存储一个对象（该对象会被序列化保存）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public async Task<bool> StringSetAsync<T>(string redisKey, string redisValue, TimeSpan? expired = null)
        {
            var json = Serialize(redisValue);
            return await _db.StringSetAsync(redisKey, json, expired);
        }
        /// <summary>
        /// 获取一个对象（反序列化）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public async Task<T> StringGetAsync<T>(string redisKey, string redisValue, TimeSpan? expired = null)
        {
            return Deserialize<T>(await _db.StringGetAsync(redisKey));
        }
        #endregion

        #region  Hash

        /// <summary>
        /// 判断字段是否在hash中
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public bool HashExist(string redisKey, string hashField)
        {
            return _db.HashExists(redisKey, hashField);
        }
        /// <summary>
        /// 从hash 中删除字段
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public bool HashDelete(string redisKey, string hashField)
        {
            return _db.HashDelete(redisKey, hashField);
        }
        /// <summary>
        /// 从hash中移除指定字段
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public long HashDelete(string redisKey, IEnumerable<RedisValue> hashField)
        {
            return _db.HashDelete(redisKey, hashField.ToArray());
        }
        /// <summary>
        /// 在hash中设定值
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="hashField"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool HashSet(string redisKey, string hashField, string value)
        {
            return _db.HashSet(redisKey, hashField, value);
        }

        /// <summary>
        /// 从Hash 中获取值
        /// </summary>
        public RedisValue HashGet(string redisKey, string hashField)
        {
            return _db.HashGet(redisKey, hashField);
        }

        /// <summary>
        /// 从Hash 中获取值
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public RedisValue[] HashGet(string redisKey, RedisValue[] hashField)
        {
            return _db.HashGet(redisKey, hashField);
        }

        /// <summary>
        /// 获取所有
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public HashEntry[] HashGetAll(string redisKey)
        {
            return _db.HashGetAll(redisKey);
        }
        /// <summary>
        /// 从hash 返回所有的key值
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public IEnumerable<RedisValue> HashKeys(string redisKey)
        {
            return _db.HashKeys(redisKey);
        }

        /// <summary>
        /// 根据key返回hash中的值
        /// </summary>
        public RedisValue[] HashValues(string redisKey)
        {
            return _db.HashValues(redisKey);
        }

        /// <summary>
        /// 根据关键词模糊匹配所有key
        /// </summary>
        /// <param name="keyPattern"></param>
        /// <returns></returns>
        public string[] AllKeys(string keyPattern)
        {
            var script = "return redis.call('keys',@pattern)";
            var prepared = LuaScript.Prepare(script);
            var cacheResult = _db.ScriptEvaluate(prepared, new { pattern = keyPattern });
            if (cacheResult.IsNull)
            {
                return null;
            }
            return (string[])cacheResult;
        }

        /// <summary>
        /// 在hash中设定值
        /// </summary>
        public bool HashSet<T>(string redisKey, string hashField, T value)
        {
            var json = Serialize(value);
            return _db.HashSet(redisKey, hashField, json);
        }

        /// <summary>
        /// 在hash 中获取值 （反序列化）
        /// </summary>
        public T HashGet<T>(string redisKey, string hashField)
        {
            return Deserialize<T>(_db.HashGet(redisKey, hashField));
        }

        /// <summary>
        /// 在hash 中获取所有值 （反序列化）
        /// </summary>
        public List<T> HashGetAll<T>(string RedisKey)
        {
            var all = _db.HashValues(RedisKey);
            if (all == null || all.Count() < 1)
                return default;
            return all.Select(x => Deserialize<T>(x)).ToList();
        }

        /// <summary>
        /// 在hash中设定值 json序列化
        /// </summary>
        public bool HashSetJosn<T>(string redisKey, string hashField, T value)
        {
            var json = JsonHelper.Object2Json(value);
            return _db.HashSet(redisKey,hashField,json);
        }

        /// <summary>
        /// 在hash 中获取值 json反序列化
        /// </summary>
        public T HashGetJson<T>(string redisKey, string hashField)
        {
            var redisValue = _db.HashGet(redisKey, hashField);
            return JsonHelper.Json2Object<T>(redisValue);
        }

        /// <summary>
        /// 在hash 中删除 hashkey
        /// </summary>
        public bool HashDeleteJson(string redisKey, string hashField)
        {
            return _db.HashDelete(redisKey, hashField);
        }

        /// <summary>
        /// 判断字段是否存在hash 中
        /// </summary>
        public async Task<bool> HashExistsAsync(string redisKey, string hashField)
        {
            return await _db.HashExistsAsync(redisKey, hashField);
        }

        /// <summary>
        /// 从hash中移除指定字段
        /// </summary>
        public async Task<bool> HashDeleteAsync(string redisKey, string hashField)
        {
            return await _db.HashDeleteAsync(redisKey, hashField);
        }

        /// <summary>
        /// 从hash中移除指定字段
        /// </summary>
        public async Task<long> HashDeleteAsync(string redisKey, IEnumerable<RedisValue> hashField)
        {
            return await _db.HashDeleteAsync(redisKey, hashField.ToArray());
        }

        /// <summary>
        /// 在hash 设置值
        /// </summary>
        public async Task<bool> HashSetAsync(string redisKey, string hashField, string value)
        {
            return await _db.HashSetAsync(redisKey, hashField, value);
        }
       
        /// <summary>
        /// 在hash 中设定值
        /// </summary>
        public async Task HashSetAsync(string redisKey, IEnumerable<HashEntry> hashFields)
        {
            await _db.HashSetAsync(redisKey, hashFields.ToArray());
        }

        /// <summary>
        /// 在hash 中设定值
        /// </summary>
        public async Task<RedisValue> HashGetAsync(string redisKey, string hashField)
        {
            return await _db.HashGetAsync(redisKey, hashField);
        }

        /// <summary>
        /// 在hash 中获取值
        /// </summary>
        public async Task<IEnumerable<RedisValue>> HashGetAsync(string redisKey, RedisValue[] hashField, string value)
        {
            return await _db.HashGetAsync(redisKey, hashField);
        }

        /// <summary>
        /// 从hash返回所有的字段值
        /// </summary>
        public async Task<IEnumerable<RedisValue>> HashKeysAsync(string redisKey)
        {
            return await _db.HashKeysAsync(redisKey);
        }

        /// <summary>
        /// 返回hash中所有的值
        /// </summary>
        public async Task<IEnumerable<RedisValue>> HashValuesAsync(string redisKey)
        {
            return await _db.HashValuesAsync(redisKey);
        }

        /// <summary>
        /// 在hash 中设定值（序列化）
        /// </summary>
        public async Task<bool> HashSetAsync<T>(string redisKey, string hashField, T value)
        {
            var json = Serialize(value);
            return await _db.HashSetAsync(redisKey, hashField, json);
        }

        /// <summary>
        /// 在hash中获取值（反序列化）
        /// </summary>
        public async Task<T> HashGetAsync<T>(string redisKey, string hashField)
        {
            return Deserialize<T>(await _db.HashGetAsync(redisKey, hashField));
        }
        #endregion

        #region list operation

        /// <summary>
        /// 移除并返回key所对应列表的第一个元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public string ListLeftPop(string redisKey)
        {
            return _db.ListLeftPop(redisKey);
        }

        /// <summary>
        /// 移除并返回key所对应列表的最后一个元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public string ListRightPop(string redisKey)
        {
            return _db.ListRightPop(redisKey);
        }
        /// <summary>
        /// 移除指定key及key所对应的元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public long ListRemove(string redisKey, string redisValue)
        {
            return _db.ListRemove(redisKey, redisValue);
        }
        /// <summary>
        /// 在列表尾部插入值，如果键不存在，先创建再插入值
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public long ListRightPush(string redisKey, string redisValue)
        {
            return _db.ListRightPush(redisKey, redisValue);
        }
        /// <summary>
        /// 在列表头部插入值，如果键不存在，先创建再插入值
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public long ListLeftPush(string redisKey, string redisValue)
        {
            return _db.ListLeftPush(redisKey, redisValue);
        }

        /// <summary>
        /// 在列表头部插入值，如果键不存在，创建后插入值,先创建再插入值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public long ListLeftPush<T>(string redisKey, T redisValue)
        {
            return _db.ListRightPush(redisKey, Serialize(redisValue));
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        public void ListLtrim(string redisKey, long start, long stop)
        {
            _db.ListTrim(redisKey, start, stop);
        }

        /// <summary>
        /// 返回列表上该键的长度，如果不存在，返回0
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public long ListLength(string redisKey)
        {
            return _db.ListLength(redisKey);
        }
        /// <summary>
        /// 返回在该列表上键所对应的元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public IEnumerable<RedisValue> ListRange(string redisKey)
        {
            try
            {
                return _db.ListRange(redisKey);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 返回在该列表上键所对应的元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="iCount">获取记录数量,默认一条</param>
        /// <param name="isAutoPrefix">是否加入前缀</param>
        /// <returns></returns>
        public IEnumerable<RedisValue> ListLastRecord(string redisKey, int iCount = 1)
        {
            try
            {
                return _db.ListRange(redisKey, 0, iCount - 1);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 移除并返回存储在该键列表的第一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public T ListLeftPop<T>(string redisKey)
        {
            return Deserialize<T>(_db.ListLeftPop(redisKey));
        }
        /// <summary>
        /// 移除并返回该列表上的最后一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public T ListRightPop<T>(string redisKey)
        {
            return Deserialize<T>(_db.ListRightPop(redisKey));
        }
        /// <summary>
        /// 在列表尾部插入值，如果键不存在，先创建再插入值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public long ListRightPush<T>(string redisKey, T redisValue)
        {
            return _db.ListRightPush(redisKey, Serialize(redisValue));
        }

        /// <summary>
        /// 移除并返回存储在该键列表的第一个元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<string> ListLeftPopAsync(string redisKey)
        {
            return await _db.ListLeftPopAsync(redisKey);
        }
        /// <summary>
        /// 移除并返回存储在该键列表的最后一个元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<string> ListRightPopAsync(string redisKey)
        {
            return await _db.ListRightPopAsync(redisKey);
        }
        /// <summary>
        /// 移除列表指定键上与值相同的元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<long> ListRemoveAsync(string redisKey, string redisValue)
        {
            return await _db.ListRemoveAsync(redisKey, redisValue);
        }
        /// <summary>
        /// 在列表尾部差入值，如果键不存在，先创建后插入
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public async Task<long> ListRightPushAsync(string redisKey, string redisValue)
        {
            return await ListRightPushAsync(redisKey, redisValue);
        }
        /// <summary>
        /// 在列表头部插入值，如果键不存在，先创建后插入
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public async Task<long> ListLeftPushAsync(string redisKey, string redisValue)
        {
            return await _db.ListLeftPushAsync(redisKey, redisValue);
        }
        /// <summary>
        /// 返回列表上的长度，如果不存在，返回0
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<long> ListLengthAsync(string redisKey)
        {
            return await _db.ListLengthAsync(redisKey);
        }
        /// <summary>
        /// 返回在列表上键对应的元素
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<IEnumerable<RedisValue>> ListRangeAsync(string redisKey)
        {
            return await _db.ListRangeAsync(redisKey);
        }
        /// <summary>
        /// 移除并返回存储在key对应列表的第一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<T> ListLeftPopAsync<T>(string redisKey)
        {
            return Deserialize<T>(await _db.ListLeftPopAsync(redisKey));
        }
        /// <summary>
        /// 移除并返回存储在key 对应列表的最后一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<T> ListRightPopAsync<T>(string redisKey)
        {
            return Deserialize<T>(await _db.ListRightPopAsync(redisKey));
        }
        /// <summary>
        /// 在列表尾部插入值，如果值不存在，先创建后写入值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public async Task<long> ListRightPushAsync<T>(string redisKey, string redisValue)
        {
            return await _db.ListRightPushAsync(redisKey, Serialize(redisValue));
        }
        /// <summary>
        /// 在列表头部插入值，如果值不存在，先创建后写入值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public async Task<long> ListLeftPushAsync<T>(string redisKey, string redisValue)
        {
            return await _db.ListLeftPushAsync(redisKey, Serialize(redisValue));
        }
        #endregion

        #region SortedSet 操作

        /// <summary>
        /// sortedset 新增
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="member"></param>
        /// <param name="score"></param>
        /// <returns></returns>
        public bool SortedSetAdd(string redisKey, string member, double score)
        {
            return _db.SortedSetAdd(redisKey, member, score);
        }
        /// <summary>
        /// 在有序集合中返回指定范围的元素，默认情况下由低到高
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public IEnumerable<RedisValue> SortedSetRangeByRank(string redisKey)
        {
            return _db.SortedSetRangeByRank(redisKey);
        }
        /// <summary>
        /// 返回有序集合的个数
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public long SortedSetLength(string redisKey)
        {
            return _db.SortedSetLength(redisKey);
        }
        /// <summary>
        /// 返回有序集合的元素个数
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="member"></param>
        /// <returns></returns>
        public bool SortedSetLength(string redisKey, string member)
        {
            return _db.SortedSetRemove(redisKey, member);
        }
        /// <summary>
        ///  sorted set Add
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="member"></param>
        /// <param name="score"></param>
        /// <returns></returns>
        public bool SortedSetAdd<T>(string redisKey, T member, double score)
        {
            var json = Serialize(member);
            return _db.SortedSetAdd(redisKey, json, score);
        }

        #region SortedSet-Async
        /// <summary>
        /// SortedSet 新增
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="member"></param>
        /// <param name="score"></param>
        /// <returns></returns>
        public async Task<bool> SortedSetAddAsync(string redisKey, string member, double score)
        {
            return await _db.SortedSetAddAsync(redisKey, member, score);
        }
        /// <summary>
        /// 在有序集合中返回指定范围的元素，默认情况下由低到高
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<IEnumerable<RedisValue>> SortedSetRangeByRankAsync(string redisKey)
        {
            return await _db.SortedSetRangeByRankAsync(redisKey);
        }
        /// <summary>
        /// 返回有序集合的元素个数
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<long> SortedSetLengthAsync(string redisKey)
        {
            return await _db.SortedSetLengthAsync(redisKey);
        }
        /// <summary>
        /// 返回有序集合的元素个数
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="member"></param>
        /// <returns></returns>
        public async Task<bool> SortedSetRemoveAsync(string redisKey, string member)
        {
            return await _db.SortedSetRemoveAsync(redisKey, member);
        }
        /// <summary>
        /// SortedSet 新增
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisKey"></param>
        /// <param name="member"></param>
        /// <param name="score"></param>
        /// <returns></returns>
        public async Task<bool> SortedSetAddAsync<T>(string redisKey, T member, double score)
        {
            var json = Serialize(member);
            return await _db.SortedSetAddAsync(redisKey, json, score);
        }
        #endregion SortedSet-Async

        #endregion

        #region key operation
        /// <summary>
        /// 移除指定key
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public bool KeyDelete(string redisKey)
        {
            return _db.KeyDelete(redisKey);
        }

        /// <summary>
        /// 移除start开始的所有key
        /// </summary>
        /// <param name="start">开始字符</param>
        /// <returns></returns>
        public long KeyDeleteStartWidth(string start)
        {

            var mutlti = GetConnectionRedisMultiplexer();

            List<string> keyList = new List<string>();
            var endpoints = mutlti.GetEndPoints();
            foreach (var ep in endpoints)
            {
                IServer server = mutlti.GetServer(ep);
                var keys = server.Keys(0, string.Format("{0}*", start));
                foreach (var item in keys)
                {
                    keyList.Add((string)item);
                }
            }

            //redisKey = AddKeyPrefix(redisKey);
            var keys2 = keyList.Select(x => (RedisKey)x);
            return _db.KeyDelete(keys2.ToArray());
        }
        /// <summary>
        /// 删除指定key
        /// </summary>
        /// <param name="redisKeys"></param>
        /// <returns></returns>
        public long KeyDelete(IEnumerable<string> redisKeys)
        {
            var keys = redisKeys.Select(x => (RedisKey)x);
            return _db.KeyDelete(keys.ToArray());
        }

        /// <summary>
        /// 所有key
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public List<string> AllKey()
        {
            var mutlti = GetConnectionRedisMultiplexer();
            var endpoints = mutlti.GetEndPoints();
            List<string> keyList = new List<string>();
            foreach (var ep in endpoints)
            {
                var server = mutlti.GetServer(ep);
                var keys = server.Keys(0, "*");
                foreach (var item in keys)
                {
                    keyList.Add((string)item);
                }
            }
            //mutlti.Close(true);
            return keyList;
            //
            //throw new Exception(string.Join(",", keyList));
        }

        /// <summary>
        /// 检验key是否存在
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public List<string> AllKeyStartWidth(string start)
        {

            var mutlti = GetConnectionRedisMultiplexer();
            var endpoints = mutlti.GetEndPoints();
            List<string> keyList = new List<string>();
            foreach (var ep in endpoints)
            {
                var server = mutlti.GetServer(ep);
                var keys = server.Keys(0, string.Format("{0}*", start));
                foreach (var item in keys)
                {
                    keyList.Add((string)item);
                }
            }

            //mutlti.Close(true);
            return keyList;
        }

        /// <summary>
        /// 检验key是否存在
        /// </summary>
        /// <param name="pattern">外部输入匹配字符</param>
        /// <returns></returns>
        public List<RedisKey> AllKeyPattern(string pattern)
        {

            var mutlti = GetConnectionRedisMultiplexer();
            var endpoints = mutlti.GetEndPoints();
            //List<string> keyList = new List<string>();

            var keyList = new List<RedisKey>();
            foreach (var ep in endpoints)
            {
                var server = mutlti.GetServer(ep);
                var keys = server.Keys(0, pattern);
                foreach (var item in keys)
                {
                    keyList.Add(item);
                }
            }

            //mutlti.Close(true);
            return keyList;
        }

        /// <summary>
        /// 检验key是否存在
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public bool KeyExists(string redisKey)
        {
            return _db.KeyExists(redisKey);
        }
        /// <summary>
        /// 重命名key
        /// </summary>
        /// <param name="oldKeyName"></param>
        /// <param name="newKeyName"></param>
        /// <returns></returns>
        public bool KeyReName(string oldKeyName, string newKeyName)
        {
            return _db.KeyRename(oldKeyName, newKeyName);
        }
        /// <summary>
        /// 设置key 的过期时间
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public bool KeyExpire(string redisKey, TimeSpan? expired = null)
        {
            return _db.KeyExpire(redisKey, expired);
        }

        #region key-async
        /// <summary>
        /// 移除指定的key
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<bool> KeyDeleteAsync(string redisKey)
        {
            return await _db.KeyDeleteAsync(redisKey);
        }
        /// <summary>
        /// 删除指定的key
        /// </summary>
        /// <param name="redisKeys"></param>
        /// <returns></returns>
        public async Task<long> KeyDeleteAsync(IEnumerable<string> redisKeys)
        {
            var keys = redisKeys.Select(x => (RedisKey)x);
            return await _db.KeyDeleteAsync(keys.ToArray());
        }
        /// <summary>
        /// 检验key 是否存在
        /// </summary>
        /// <param name="redisKey"></param>
        /// <returns></returns>
        public async Task<bool> KeyExistsAsync(string redisKey)
        {
            return await _db.KeyExistsAsync(redisKey);
        }
        /// <summary>
        /// 重命名key
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="redisNewKey"></param>
        /// <returns></returns>
        public async Task<bool> KeyRenameAsync(string redisKey, string redisNewKey)
        {
            return await _db.KeyRenameAsync(redisKey, redisNewKey);
        }
        /// <summary>
        /// 设置 key 时间
        /// </summary>
        /// <param name="redisKey"></param>
        /// <param name="expired"></param>
        /// <returns></returns>
        public async Task<bool> KeyExpireAsync(string redisKey, TimeSpan? expired)
        {
            return await _db.KeyExpireAsync(redisKey, expired);
        }
        #endregion key-async

        #endregion

        #region 发布订阅
        /// <summary>
        /// 订阅
        /// </summary>
        /// <param name="channel">频道</param>
        /// <param name="handle">事件</param>
        public void Subscribe(RedisChannel channel, Action<RedisChannel, RedisValue> handle)
        {
            //getSubscriber() 获取到指定服务器的发布者订阅者的连接
            var sub = _connMultiplexer.GetSubscriber();
            //订阅执行某些操作时改变了 优先/主动 节点广播
            sub.Subscribe(channel, handle);
        }
        /// <summary>
        /// 发布
        /// </summary>
        /// <param name="channel"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public long Publish(RedisChannel channel, RedisValue message)
        {
            var sub = _connMultiplexer.GetSubscriber();
            return sub.Publish(channel, message);
        }
        /// <summary>
        /// 发布（使用序列化）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="channel"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public long Publish<T>(RedisChannel channel, T message)
        {
            var sub = _connMultiplexer.GetSubscriber();
            return sub.Publish(channel, Serialize(message));
        }

        #region 发布订阅-async
        /// <summary>
        /// 订阅
        /// </summary>
        /// <param name="redisChannel"></param>
        /// <param name="handle"></param>
        /// <returns></returns>
        public async Task SubscribeAsync(RedisChannel redisChannel, Action<RedisChannel, RedisValue> handle)
        {
            var sub = _connMultiplexer.GetSubscriber();
            await sub.SubscribeAsync(redisChannel, handle);
        }
        /// <summary>
        /// 发布
        /// </summary>
        /// <param name="redisChannel"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public async Task<long> PublishAsync(RedisChannel redisChannel, RedisValue message)
        {
            var sub = _connMultiplexer.GetSubscriber();
            return await sub.PublishAsync(redisChannel, message);
        }
        /// <summary>
        /// 发布（使用序列化）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="redisChannel"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public async Task<long> PublishAsync<T>(RedisChannel redisChannel, T message)
        {
            var sub = _connMultiplexer.GetSubscriber();
            return await sub.PublishAsync(redisChannel, Serialize(message));
        }
        #endregion 发布订阅-async

        #endregion

        #region 注册事件
        /// <summary>
        /// 注册事件
        /// </summary>
        private static void RegisterEvent()
        {
            _connMultiplexer.ConnectionRestored += ConnMultiplexer_ConnectionRestored;
            _connMultiplexer.ConnectionFailed += ConnMultiplexer_ConnectionFailed;
            _connMultiplexer.ErrorMessage += ConnMultiplexer_ErrorMessage;
            _connMultiplexer.ConfigurationChanged += ConnMultiplexer_ConfigurationChanged;
            _connMultiplexer.HashSlotMoved += ConnMultiplexer_HashSlotMoved;
            _connMultiplexer.InternalError += ConnMultiplexer_InternalError;
            _connMultiplexer.ConfigurationChangedBroadcast += ConnMultiplexer_ConfigurationChangedBroadcast;
        }
        /// <summary>
        /// 重新配置广播时(主从同步更改)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void ConnMultiplexer_ConfigurationChangedBroadcast(object sender, EndPointEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChangedBroadcast)}: {e.EndPoint}");
        }
        /// <summary>
        /// 发生内部错误时(调试用)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void ConnMultiplexer_InternalError(object sender, InternalErrorEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_InternalError)}: {e.Exception}");
        }
        /// <summary>
        /// 更改集群时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void ConnMultiplexer_HashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_HashSlotMoved)}: {nameof(e.OldEndPoint)}-{e.OldEndPoint} To {nameof(e.NewEndPoint)}-{e.NewEndPoint} ");
        }
        /// <summary>
        /// 配置更改时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void ConnMultiplexer_ConfigurationChanged(object sender, EndPointEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChanged)}: {e.EndPoint}");
        }
        /// <summary>
        /// 发生错误时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void ConnMultiplexer_ErrorMessage(object sender, RedisErrorEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ErrorMessage)}: {e.Message}");
        }
        /// <summary>
        /// 物理连接失败时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void ConnMultiplexer_ConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionFailed)}: {e.Exception}");
        }
        /// <summary>
        /// 建立物理连接时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void ConnMultiplexer_ConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionRestored)}: {e.Exception}");
        }
        #endregion
    }
}