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

namespace APT.Infrastructure.Api
{
    /// <summary>
    /// 缓存管理
    /// 1.要可以查看所有的缓存
    /// 2.要可以管理缓存中的数据，如清空，删除等
    /// 3.可以预先加载
    /// </summary>
    public class RedisManager
    {
        public int DbNum { get; }
        public ConnectionMultiplexer _conn;

        JsonSerializerSettings _jsonSetting;

        #region 构造函数

        public RedisManager(int dbNum = 0)
        {
            DbNum = dbNum;
            _conn = RedisConfig.Instance;
            _jsonSetting = new JsonSerializerSettings();
            _jsonSetting.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
        }
        #endregion 构造函数

        #region String
        #region 同步方法

        ///// <summary>
        ///// 保存单个key value
        ///// </summary>
        ///// <param name="key">Redis Key</param>
        ///// <param name="value">保存的值</param>
        ///// <param name="expiry">过期时间</param>
        ///// <returns></returns>
        //public bool StringSet(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db => db.StringSet(key, value, expiry));
        //}

        ///// <summary>
        ///// 保存多个key value
        ///// </summary>
        ///// <param name="keyValues">键值对</param>
        ///// <returns></returns>
        //public bool StringSet(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
        //{
        //    List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
        //        keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToList();
        //    return Do(db => db.StringSet(newkeyValues.ToArray()));
        //}

        ///// <summary>
        ///// 保存一个对象
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <param name="obj"></param>
        ///// <param name="expiry"></param>
        ///// <returns></returns>
        //public bool StringSet<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
        //{
        //    key = AddSysCustomKey(key);
        //    string json = ConvertJson(obj);
        //    return Do(db => db.StringSet(key, json, expiry));
        //}

        ///// <summary>
        ///// 保存一个对象
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <param name="obj"></param>
        ///// <param name="expiry"></param>
        ///// <returns></returns>
        //public bool StringSet<T>(string key, T obj, DateTime expiry)
        //{
        //    key = AddSysCustomKey(key);
        //    string json = ConvertJson(obj);
        //    return Do(db => db.StringSet(key, json, expiry - DateTime.Now));
        //}

        ///// <summary>
        ///// 获取单个key的值
        ///// </summary>
        ///// <param name="key">Redis Key</param>
        ///// <returns></returns>
        //public string StringGet(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db => db.StringGet(key));
        //}

        ///// <summary>
        ///// 获取多个Key
        ///// </summary>
        ///// <param name="listKey">Redis Key集合</param>
        ///// <returns></returns>
        //public RedisValue[] StringGet(List<string> listKey)
        //{
        //    List<string> newKeys = listKey.Select(AddSysCustomKey).ToList();
        //    return Do(db => db.StringGet(ConvertRedisKeys(newKeys)));
        //}

        ///// <summary>
        ///// 获取一个key的对象
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public T StringGet<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db => ConvertObj<T>(db.StringGet(key)));
        //}

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

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

        //#endregion 同步方法

        //#region 异步方法

        ///// <summary>
        ///// 保存单个key value
        ///// </summary>
        ///// <param name="key">Redis Key</param>
        ///// <param name="value">保存的值</param>
        ///// <param name="expiry">过期时间</param>
        ///// <returns></returns>
        //public async Task<bool> StringSetAsync(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        //{
        //    key = AddSysCustomKey(key);
        //    return await Do(db => db.StringSetAsync(key, value, expiry));
        //}

        ///// <summary>
        ///// 保存多个key value
        ///// </summary>
        ///// <param name="keyValues">键值对</param>
        ///// <returns></returns>
        //public async Task<bool> StringSetAsync(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
        //{
        //    List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
        //        keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToList();
        //    return await Do(db => db.StringSetAsync(newkeyValues.ToArray()));
        //}

        ///// <summary>
        ///// 保存一个对象
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <param name="obj"></param>
        ///// <param name="expiry"></param>
        ///// <returns></returns>
        //public async Task<bool> StringSetAsync<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
        //{
        //    key = AddSysCustomKey(key);
        //    string json = ConvertJson(obj);
        //    return await Do(db => db.StringSetAsync(key, json, expiry));
        //}

        ///// <summary>
        ///// 获取单个key的值
        ///// </summary>
        ///// <param name="key">Redis Key</param>
        ///// <returns></returns>
        //public async Task<string> StringGetAsync(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return await Do(db => db.StringGetAsync(key));
        //}

        ///// <summary>
        ///// 获取多个Key
        ///// </summary>
        ///// <param name="listKey">Redis Key集合</param>
        ///// <returns></returns>
        //public async Task<RedisValue[]> StringGetAsync(List<string> listKey)
        //{
        //    List<string> newKeys = listKey.Select(AddSysCustomKey).ToList();
        //    return await Do(db => db.StringGetAsync(ConvertRedisKeys(newKeys)));
        //}

        ///// <summary>
        ///// 获取一个key的对象
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public async Task<T> StringGetAsync<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    string result = await Do(db => db.StringGetAsync(key));
        //    return ConvertObj<T>(result);

        //}

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

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

        //#endregion 异步方法

        //#endregion String

        //#region Hash

        //#region 同步方法

        /// <summary>
        /// 判断某个数据是否已经被缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool HashExists(string key, string dataKey)
        {
            if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(dataKey))
                return false;
            key = AddSysCustomKey(key);
            return Do(db => db.HashExists(key, dataKey));
        }

        ///// <summary>
        ///// 存储数据到hash表
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <param name="dataKey"></param>
        ///// <param name="t"></param>
        ///// <returns></returns>
        //public bool HashSet<T>(string key, string dataKey, T t)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db =>
        //    {
        //        string json = ConvertJson(t);
        //        return db.HashSet(key, dataKey, json);
        //    });
        //}

        /// <summary>
        /// 移除hash中的某值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool HashDelete(string key, string dataKey)
        {
            if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(dataKey))
                return false;
            key = AddSysCustomKey(key);
            return Do(db => db.HashDelete(key, dataKey));
        }

        ///// <summary>
        ///// 移除hash中的多个值
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="dataKeys"></param>
        ///// <returns></returns>
        //public long HashDelete(string key, List<RedisValue> dataKeys)
        //{
        //    key = AddSysCustomKey(key);
        //    //List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
        //    return Do(db => db.HashDelete(key, dataKeys.ToArray()));
        //}

        /// <summary>
        /// 从hash表获取数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public T HashGet<T>(string key, string dataKey)
        {
            if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(dataKey))
                return default(T);
            key = AddSysCustomKey(key);
            return Do(db =>
            {
                string value = db.HashGet(key, dataKey);
                if (!string.IsNullOrEmpty(value))
                    return ConvertObj<T>(value);
                else
                    return default(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)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db => db.HashIncrement(key, dataKey, val));
        //}

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

        ///// <summary>
        ///// 获取hashkey所有Redis key
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public List<T> HashKeys<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db =>
        //    {
        //        RedisValue[] values = db.HashKeys(key);
        //        return ConvetList<T>(values);
        //    });
        //}

        ///// <summary>
        ///// 
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public List<T> HashValues<T>(string key)
        //{
        //    var result = new List<T>();
        //    key = AddSysCustomKey(key);
        //    return Do(db =>
        //    {
        //        HashEntry[] arr = db.HashGetAll(key);
        //        foreach (var item in arr)
        //        {
        //            if (!item.Value.IsNullOrEmpty)
        //            {
        //                result.Add(JsonConvert.DeserializeObject<T>(item.Value));
        //            }
        //        }
        //        return result;
        //    });
        //}

        public HashEntry[] HashValueAll(string key)
        {
            key = AddSysCustomKey(key);
            return Do(db =>
            {
                HashEntry[] arr = db.HashGetAll(key);
                return arr;
            });
        }

        //#endregion 同步方法

        //#region 异步方法

        ///// <summary>
        ///// 判断某个数据是否已经被缓存
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="dataKey"></param>
        ///// <returns></returns>
        //public async Task<bool> HashExistsAsync(string key, string dataKey)
        //{
        //    key = AddSysCustomKey(key);
        //    return await Do(db => db.HashExistsAsync(key, dataKey));
        //}

        ///// <summary>
        ///// 存储数据到hash表
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <param name="dataKey"></param>
        ///// <param name="t"></param>
        ///// <returns></returns>
        //public async Task<bool> HashSetAsync<T>(string key, string dataKey, T t)
        //{
        //    key = AddSysCustomKey(key);
        //    return await Do(db =>
        //    {
        //        string json = ConvertJson(t);
        //        return db.HashSetAsync(key, dataKey, json);
        //    });
        //}

        ///// <summary>
        ///// 移除hash中的某值
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="dataKey"></param>
        ///// <returns></returns>
        //public async Task<bool> HashDeleteAsync(string key, string dataKey)
        //{
        //    key = AddSysCustomKey(key);
        //    return await Do(db => db.HashDeleteAsync(key, dataKey));
        //}

        ///// <summary>
        ///// 移除hash中的多个值
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="dataKeys"></param>
        ///// <returns></returns>
        //public async Task<long> HashDeleteAsync(string key, List<RedisValue> dataKeys)
        //{
        //    key = AddSysCustomKey(key);
        //    //List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
        //    return await Do(db => db.HashDeleteAsync(key, dataKeys.ToArray()));
        //}

        ///// <summary>
        ///// 从hash表获取数据
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <param name="dataKey"></param>
        ///// <returns></returns>
        //public async Task<T> HashGetAsync<T>(string key, string dataKey)
        //{
        //    key = AddSysCustomKey(key);
        //    string value = await Do(db => db.HashGetAsync(key, dataKey));
        //    return ConvertObj<T>(value);

        //}

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

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

        ///// <summary>
        ///// 获取hashkey所有Redis key
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public async Task<List<T>> HashKeysAsync<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    RedisValue[] values = await Do(db => db.HashKeysAsync(key));
        //    return ConvetList<T>(values);
        //}

        ///// <summary>
        ///// 
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public async Task<List<T>> HashValuesAsync<T>(string key)
        //{
        //    var result = new List<T>();
        //    key = AddSysCustomKey(key);
        //    HashEntry[] arr = await Do(db => db.HashGetAllAsync(key));
        //    foreach (var item in arr)
        //    {
        //        string values = item.Name;
        //        if (!item.Value.IsNullOrEmpty)
        //        {
        //            result.Add(JsonConvert.DeserializeObject<T>(item.Value));
        //        }
        //    }
        //    return result;
        //}
        ///// <summary>
        ///// 
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public async Task<HashEntry[]> HashValueAllAsync(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    HashEntry[] arr = await Do(db => db.HashGetAllAsync(key));
        //    return arr;
        //}
        #endregion 异步方法

        #endregion Hash

        //#region List

        //#region 同步方法

        ///// <summary>
        ///// 移除指定ListId的内部List的值
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="value"></param>
        //public void ListRemove<T>(string key, T value)
        //{
        //    key = AddSysCustomKey(key);
        //    Do(db => db.ListRemove(key, ConvertJson(value)));
        //}

        ///// <summary>
        ///// 获取指定key的List
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public List<T> ListRange<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(redis =>
        //    {
        //        var values = redis.ListRange(key);
        //        return ConvetList<T>(values);
        //    });
        //}

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

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

        ///// <summary>
        ///// 入栈
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <param name="value"></param>
        //public void ListLeftPush<T>(string key, T value)
        //{
        //    key = AddSysCustomKey(key);
        //    Do(db => db.ListLeftPush(key, ConvertJson(value)));
        //}

        ///// <summary>
        ///// 出栈
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public T ListLeftPop<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db =>
        //    {
        //        var value = db.ListLeftPop(key);
        //        return ConvertObj<T>(value);
        //    });
        //}

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

        //#endregion 同步方法

        //#region 异步方法

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

        ///// <summary>
        ///// 获取指定key的List
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public async Task<List<T>> ListRangeAsync<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    var values = await Do(redis => redis.ListRangeAsync(key));
        //    return ConvetList<T>(values);
        //}

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

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

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

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

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

        //#endregion 异步方法

        //#endregion List

        //#region SortedSet 有序集合

        //#region 同步方法

        ///// <summary>
        ///// 添加
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="value"></param>
        ///// <param name="score"></param>
        //public bool SortedSetAdd<T>(string key, T value, double score)
        //{
        //    key = AddSysCustomKey(key);

        //    return Do(redis => redis.SortedSetAdd(key, ConvertJson<T>(value), score));
        //}

        ///// <summary>
        ///// 添加????????
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="value"></param>
        ///// <param name="score"></param>
        //public double SortedSetIncrement<T>(string key, T value, double score)
        //{
        //    key = AddSysCustomKey(key);

        //    return Do(redis => redis.SortedSetIncrement(key, ConvertJson<T>(value), score));
        //}

        //public bool SortedSetAdd<T>(string key, SortedSetEntry[] values)
        //{
        //    key = AddSysCustomKey(key);
        //    Do(redis => redis.SortedSetAdd(key, values, CommandFlags.None));
        //    return true;
        //}
        //public async Task<bool> SortedSetAddAsync<T>(string key, SortedSetEntry[] values)
        //{
        //    key = AddSysCustomKey(key);
        //    await Do(redis => redis.SortedSetAddAsync(key, values));
        //    return true;
        //}
        ///// <summary>
        ///// 删除
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="value"></param>
        //public bool SortedSetRemove<T>(string key, T value)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(redis => redis.SortedSetRemove(key, ConvertJson(value)));
        //}

        ///// <summary>
        ///// 获取全部
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public List<T> SortedSetRangeByRank<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(redis =>
        //    {
        //        var values = redis.SortedSetRangeByRank(key);
        //        return ConvetList<T>(values);
        //    });
        //}

        ///// <summary>
        ///// 获取全部
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public RedisValue[] SortedSetRangeByRank(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(redis =>
        //    {
        //        return redis.SortedSetRangeByRank(key);

        //    });
        //}

        //public IEnumerable<SortedSetEntry> SortedSetScan(string key, RedisValue pattern = default)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(redis =>
        //    {
        //        return redis.SortedSetScan(key, pattern);
        //    });
        //}
        //public async Task<IAsyncEnumerable<SortedSetEntry>> SortedSetScanAsync(string key, RedisValue pattern = default)
        //{
        //    key = AddSysCustomKey(key);
        //    return  Do(redis =>
        //    {
        //        return  redis.SortedSetScanAsync(key,pattern);
        //    });
        //}


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

        //#endregion 同步方法

        //#region 异步方法

        ///// <summary>
        ///// 添加
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="value"></param>
        ///// <param name="score"></param>
        //public async Task<bool> SortedSetAddAsync<T>(string key, T value, double score)
        //{
        //    key = AddSysCustomKey(key);
        //    return await Do(redis => redis.SortedSetAddAsync(key, ConvertJson<T>(value), score));
        //}

        ///// <summary>
        ///// 删除
        ///// </summary>
        ///// <param name="key"></param>
        ///// <param name="value"></param>
        //public async Task<bool> SortedSetRemoveAsync<T>(string key, T value)
        //{
        //    key = AddSysCustomKey(key);
        //    return await Do(redis => redis.SortedSetRemoveAsync(key, ConvertJson(value)));
        //}

        ///// <summary>
        ///// 获取全部
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public async Task<List<T>> SortedSetRangeByRankAsync<T>(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    var values = await Do(redis => redis.SortedSetRangeByRankAsync(key));
        //    return ConvetList<T>(values);
        //}

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

        //#endregion 异步方法

        //#endregion SortedSet 有序集合

        //#region key

        ///// <summary>
        ///// 删除单个key
        ///// </summary>
        ///// <param name="key">redis key</param>
        ///// <returns>是否删除成功</returns>
        //public bool KeyDelete(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db => db.KeyDelete(key));
        //}
        //public async Task<bool> KeyDeleteAsync(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return await Do(db => db.KeyDeleteAsync(key));
        //}
        ///// <summary>
        ///// 删除多个key
        ///// </summary>
        ///// <param name="keys">rediskey</param>
        ///// <returns>成功删除的个数</returns>
        //public long KeyDelete(List<string> keys)
        //{
        //    List<string> newKeys = keys.Select(AddSysCustomKey).ToList();
        //    return Do(db => db.KeyDelete(ConvertRedisKeys(newKeys)));
        //}

        ///// <summary>
        ///// 判断key是否存储
        ///// </summary>
        ///// <param name="key">redis key</param>
        ///// <returns></returns>
        //public bool KeyExists(string key)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db => db.KeyExists(key));
        //}

        ///// <summary>
        ///// 重新命名key
        ///// </summary>
        ///// <param name="key">就的redis key</param>
        ///// <param name="newKey">新的redis key</param>
        ///// <returns></returns>
        //public bool KeyRename(string key, string newKey)
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db => db.KeyRename(key, newKey));
        //}

        ///// <summary>
        ///// 设置Key的时间
        ///// </summary>
        ///// <param name="key">redis key</param>
        ///// <param name="expiry"></param>
        ///// <returns></returns>
        //public bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
        //{
        //    key = AddSysCustomKey(key);
        //    return Do(db => db.KeyExpire(key, expiry));
        //}

        /// <summary>
        /// 获取所有KEY
        /// </summary>
        /// <returns></returns>
        public List<string> GetAllCacheKeys()
        {
            try
            {
                var result = new List<string>();
                var endpoints = _conn.GetEndPoints(true);
                foreach (var endpoint in endpoints)
                {
                    var server = _conn.GetServer(endpoint);
                    result.AddRange(server.Keys(DbNum).Select(x => x.ToString()));
                }
                return result.Distinct().ToList();
            }
            catch
            {
                return null;
            }
        }

        ///// <summary>
        ///// 获取所有KEY-Value
        ///// </summary>
        ///// <returns></returns>
        //public IDictionary<string, object> GetAll()
        //{
        //    try
        //    {
        //        var result = new Dictionary<string, object>();
        //        IDatabase idb = _conn.GetDatabase(DbNum);
        //        var endpoints = _conn.GetEndPoints(true);
        //        foreach (var endpoint in endpoints)
        //        {
        //            var server = _conn.GetServer(endpoint);
        //            foreach (var item in server.Keys(DbNum))
        //            {
        //                result.Add(item.ToString(), idb.StringGet(item.ToString()));
        //            }
        //        }
        //        return result;
        //    }
        //    catch
        //    {
        //        return null;
        //    }
        //}


        //#endregion key

        //#region 发布订阅

        ///// <summary>
        ///// Redis发布订阅  订阅
        ///// </summary>
        ///// <param name="subChannel"></param>
        ///// <param name="handler"></param>
        //public void Subscribe(string subChannel, Action<RedisChannel, RedisValue> handler = null)
        //{
        //    ISubscriber sub = _conn.GetSubscriber();
        //    sub.Subscribe(subChannel, (channel, message) =>
        //    {
        //        if (handler == null)
        //        {
        //            Console.WriteLine(subChannel + " 订阅收到消息：" + message);
        //        }
        //        else
        //        {
        //            handler(channel, message);
        //        }
        //    });
        //}

        ///// <summary>
        ///// Redis发布订阅  发布
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="channel"></param>
        ///// <param name="msg"></param>
        ///// <returns></returns>
        //public long Publish<T>(string channel, T msg)
        //{
        //    ISubscriber sub = _conn.GetSubscriber();
        //    return sub.Publish(channel, ConvertJson(msg));
        //}

        ///// <summary>
        ///// Redis发布订阅  取消订阅
        ///// </summary>
        ///// <param name="channel"></param>
        //public void Unsubscribe(string channel)
        //{
        //    ISubscriber sub = _conn.GetSubscriber();
        //    sub.Unsubscribe(channel);
        //}

        ///// <summary>
        ///// Redis发布订阅  取消全部订阅
        ///// </summary>
        //public void UnsubscribeAll()
        //{
        //    ISubscriber sub = _conn.GetSubscriber();
        //    sub.UnsubscribeAll();
        //}

        //#endregion 发布订阅

        #region 其他
        /// <summary>
        /// 获取list的redis
        /// </summary>
        /// <param name="orgid"></param>
        /// <returns></returns>
        public List<HashEntry> GetListKeys(Guid orgid)
        {
            return this.HashValueAll("opt_list_" + orgid).ToList();
        }
        /// <summary>
        /// 删除list中的某张表数据
        /// </summary>
        /// <param name="orgid"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public bool DeleteListKeys(Guid orgid, string name)
        {
            if (this.HashExists("opt_list_" + orgid, name))
            {
                return this.HashDelete("opt_list_" + orgid, name);
            }
            return true;
        }
        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="orgid"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public bool ExistsListKeys(Guid orgid, string name)
        {
            return this.HashExists("opt_list_" + orgid, name);
        }
        /// <summary>
        /// 获取list中表的rediskey
        /// </summary>
        /// <param name="orgid"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public string GetListKey(Guid orgid, string name)
        {
            return this.HashGet<string>("opt_list_" + orgid, name);
        }

        public ITransaction CreateTransaction()
        {
            return GetDatabase().CreateTransaction();
        }

        public IDatabase GetDatabase()
        {
            return _conn.GetDatabase(DbNum);
        }

        public IServer GetServer(string hostAndPort)
        {
            return _conn.GetServer(hostAndPort);
        }
        #endregion 其他

        #region 辅助方法

        private string AddSysCustomKey(string oldKey)
        {
            var prefixKey = RedisConfig.SysCustomKey;
            return prefixKey + oldKey;
        }

        private T Do<T>(Func<IDatabase, T> func)
        {
            try
            {
                var database = _conn.GetDatabase(DbNum);
                return func(database);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"reids.do:{ex.Message}");
                return default(T);
            }
        }

        public string ConvertJson<T>(T value)
        {
            string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value, _jsonSetting);
            return result;
        }

        //private T ConvertObj<T>(RedisValue value)
        //{
        //    if (value.HasValue)
        //    {
        //        // return SerializerJson.DeserializeObject<T>(value);
        //        return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(value);
        //        //return SerializerJson.DeserializeObject<T>(value);
        //    }
        //    return default(T);
        //}

        private T ConvertObj<T>(RedisValue value)
        {
            if (typeof(T).Name.Equals(typeof(string).Name))
            {
                return JsonConvert.DeserializeObject<T>($"'{value}'");
            }
            else
            {
                T t = JsonConvert.DeserializeObject<T>(value);
                if (t == null)
                {
                    Console.WriteLine($"reids.ConvertObj.t:{null}");
                }
                return t;
            }
        }


        private List<T> ConvetList<T>(RedisValue[] values)
        {
            List<T> result = new List<T>();
            foreach (var item in values)
            {
                var model = ConvertObj<T>(item);
                result.Add(model);
            }
            return result;
        }

        private RedisKey[] ConvertRedisKeys(List<string> redisKeys)
        {
            return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
        }

        #endregion 辅助方法

    }
}