StackExchange.redis 封装帮助类

using ModelLibrary.quotedata;
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;
using System.Text;
using System.Web.Script.Serialization;
/// <summary>
/// RedisHelperUtil 的摘要说明
/// </summary>
public class RedisHelperUtil : RedisHelper
{

    public RedisHelperUtil()
    {
        //
        // TODO: 在此处添加构造函数逻辑
        //
    }

    #region Redis内存库连接方式
    /// <summary>
    /// 本地redis
    /// </summary>
   private static string constrStack = ConfigurationManager.ConnectionStrings["LocalKeyStack"].ConnectionString;
    /// <summary>
    /// 192.168.3.252
    /// </summary>
   // private static string constrStack = ConfigurationManager.ConnectionStrings["RedisKeyStack"].ConnectionString;
    #endregion

    //1069070069

    #region batch写入数据

    #region Batch Hash写入数据
   /// <summary>
   /// Batch Hash写入数据 无数据类型
    /// </summary>
    /// <param name="key"></param>
    /// <param name="v"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static  bool HashSetForBatch(RedisKey key, RedisValue v, RedisValue t, int db) 
    {
        using (var connect = ConnectionMultiplexer.Connect(constrStack)) 
        {
            try
            {
                var client = connect.GetDatabase(db);
                var batch = client.CreateBatch();
                Task b = batch.HashSetAsync(key, v,t);
                batch.Execute();
            }
            catch (Exception e){ }
            return true;
        }
    }

    /// <summary>
    /// Batch Hash写入数据 数据类型T
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="v"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static async Task< bool> HashSetForBatch<T>(RedisKey key,RedisValue v, T t, int db) 
    {
        using (var connect = ConnectionMultiplexer.Connect(constrStack)) 
        {
            Task<bool> result=null;
            try 
            {
                var client = connect.GetDatabase(db);
                var bacth = client.CreateBatch();
                var b = bacth.HashSetAsync(key,v, RedisHelper.ConvertJson<T>(t));
                bacth.Execute();
                result = b;
            }
            catch (Exception e) { }
            return await result;
        }
    }
   #endregion

    #region Batch Set写入数据
    /// <summary>
    /// Batch Set写入数据 无数据类型
    /// </summary>
    /// <param name="key"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static async Task<long> SetAddForBatch(RedisKey key, RedisValue[] v, int db) 
    {
        using (var connect = ConnectionMultiplexer.Connect(constrStack)) 
        {
            Task<long> result = null;
            try
            {
                var client = connect.GetDatabase(db);
                var batch = client.CreateBatch();
                Task<long> b = batch.SetAddAsync(key, v);
                batch.Execute();
                result = b;
            }
            catch (Exception e) { }
            return await result;

        }
    }
    /// <summary>
    /// Batch Set写入数据 数据类型T
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static async Task <bool> SetAddForBatch<T>(RedisKey key, T t, int db) 
    {
        using (var connect = ConnectionMultiplexer.Connect(constrStack)) 
        {
            Task<bool> result = null;
            try
            {
                var client = connect.GetDatabase(db);
                var batch = client.CreateBatch();
                Task<bool> b = batch.SetAddAsync(key, RedisHelper.ConvertJson<T>(t));
                batch.Execute();
                result = b;
            }
            catch { }
            return await result;
        }
    }

    #endregion

    #endregion

    #region bacth读取数据

    #region Batch 读取Hash
    /// <summary>
    /// Batch 读取Hash所有的值
    /// </summary>
    /// <param name="key"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static HashEntry[] HashGetAllForBatch(RedisKey key, int db)
    {
        HashEntry[] hash = null;
        List<Task<HashEntry[]>> valueList = new List<Task<HashEntry[]>>();
        try
        {
            using (var connect = ConnectionMultiplexer.Connect(constrStack))
            {
                var client = connect.GetDatabase(db);
                var batch = client.CreateBatch();
                Task<HashEntry[]> tres = batch.HashGetAllAsync(key);
                valueList.Add(tres);
                batch.Execute();
                foreach (var hashEntry in valueList)
                {
                    hash = hashEntry.Result;
                    //var dic = hashEntry.Result.ToDictionary(k => k.Name, v => v.Value);
                    //var keys = dic.Keys;
                }
            }
        }
        catch (Exception e) { }
        return hash;
    }
    #endregion

    #region Batch 读取List
    /// <summary>
    /// Batch 读取List所有的值
    /// </summary>
    /// <param name="key"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static RedisValue[] ListGetAllForBatch(RedisKey key, int db)
    {
        RedisValue[] redis = null;
        List<Task<RedisValue[]>> valueList = new List<Task<RedisValue[]>>();
        try
        {
            using (var connect = ConnectionMultiplexer.Connect(constrStack))
            {
                var client = connect.GetDatabase(db);
                var batch = client.CreateBatch();
                Task<RedisValue[]> list = batch.ListRangeAsync(key);
                valueList.Add(list);
                batch.Execute();
                foreach (var RedisValue in valueList)
                {
                    redis = RedisValue.Result;
                }
            }
        }
        catch (Exception e) { }
        return redis;
    }
    #endregion

    #region  Batch 读取SortedSet
    /// <summary>
    /// 获取SortedSet的全部数据
    /// </summary>
    /// <param name="key"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static RedisValue[] SortedSetRangeByRankAllForBatch(RedisKey key, int db) 
    {
        RedisValue[] redis = null;
        List<Task<RedisValue[]>> value = new List<Task<RedisValue[]>>();
        using (var connect = ConnectionMultiplexer.Connect(constrStack)) 
        {
            try 
            {
                var client = connect.GetDatabase(db);
                var batch = client.CreateBatch();
                Task<RedisValue []> list = batch.SortedSetRangeByRankAsync(key);;
                value.Add(list);
                batch.Execute();
                foreach (var v in value) 
                {
                    redis = v.Result;
                }
            }
            catch (Exception e) { }
            return redis;
        }
    }
    #endregion
    #endregion

    #region redis数据类型为string

    #region 保存单个 value
    /// <summary>
    /// 保存单个 value
    /// 设置一个string的键，如果存在 就会被重写
    /// </summary>
    /// <param name="TableName">表名</param>
    /// <param name="value">值</param>
    /// <param name="db">数据库</param>
    /// <returns></returns>
    public static bool StringSet(string TableName, string value, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).StringSet(TableName, value);
        }
    }

    public static bool StringSet<T>(RedisKey key, T v, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            return client.GetDatabase(db).StringSet(key, RedisHelper.ConvertJson<T>(v));
        }
    }
    #endregion

    #region 保存多个 value
    /// <summary>
    /// 批量保存多个值
    /// </summary>
    /// <param name="TableName">数组 表名</param>
    /// <param name="value">数组 值</param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static bool StringSet(string[] TableName, string[] value, int db)
    {
        //实例： 
        //string [] tabname = {"a1","a2","a3" };
        //string[] key = { "key1", "key2", "key3" };
        //var result = RedisHelperUtil.StringSet(tabname, key, dbt);

        var count = TableName.Length;
        var keyValuePair = new KeyValuePair<RedisKey, RedisValue>[count];
        for (int i = 0; i < count; i++)
        {
            keyValuePair[i] = new KeyValuePair<RedisKey, RedisValue>(TableName[i], value[i]);
        }
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).StringSet(keyValuePair);
        }
    }
    #endregion

    #region String读取单个值
    /// <summary>
    /// String读取单个值
    /// </summary>
    /// <param name="TableName">表名</param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static string StringGet(string TableName, int db)
    {
        //实例：
        //var result = RedisHelperUtil.StringGet("a1", dbt);
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).StringGet(TableName);
        }
    }
    /// <summary>
    /// String读取单个值 数据类型T 返回对象T
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static T StringGet<T>(RedisKey key, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            var value = client.GetDatabase(db).StringGet(key);
            return RedisHelper.ConvertObj<T>(value);
        }
    }
    #endregion

    #region string批量读取
    /// <summary>
    /// string批量读取
    /// </summary>
    /// <param name="keyStrs"></param>
    /// <param name="dbt"></param>
    /// <returns></returns>

    public static RedisValue[] StringGet(RedisKey[] TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).StringGet(TableName);
        }
    }
    /// <summary>
    /// string批量读取 数据类型T 返回List<T> 集合
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static List<T> StringGet<T>(RedisKey[] key, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            RedisValue[] v = client.GetDatabase(db).StringGet(key);
            return RedisHelper.ConvetList<T>(v);
        }
    }

    #endregion

    #region 数字增长val
    /// <summary>
    /// String 数字增长val，返回自增后的值
    /// </summary>
    /// <param name="key"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static double StringIncrement(RedisKey key, double v, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            return client.GetDatabase(db).StringIncrement(key, v);
        }
    }
    #endregion

    #region 数字减少v
    /// <summary>
    /// 数字减少v，返回自减少的值
    /// </summary>
    /// <param name="key"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static double StringDecrement(RedisKey key, double v, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            return client.GetDatabase(db).StringDecrement(key, v);
        }
    }
    #endregion
    #endregion

    #region redis数据类型为hash

    #region 判断某个hash数据是否存在
    /// <summary>
    /// 判断某个hash数据是否存在
    /// </summary>
    /// <param name="TableName">表名</param>
    /// <param name="dataKey">键名</param>
    /// <param name="dbt">数据库名</param>
    /// <returns></returns>
    public static bool HashExists(string TableName, string dataKey, int dbt)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(dbt).HashExists(TableName, dataKey);
        }
    }
    #endregion

    #region Hash 存储一个数据
    /// <summary>
    /// Hash 存储一个数据 数据类型T
    /// 如果这个hsah不存在则创建新的hash键返回true,如果不存在则这个hash键会被重写 返回false
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName">表名</param>
    /// <param name="dataKey">键名</param>
    /// <param name="dbt">数据库</param>
    /// <param name="t">json格式字符串</param>
    /// <returns></returns>
    public static bool HashSet<T>(string TableName, string dataKey, int dbt, T t)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            var json = RedisHelper.ConvertJson(t);
            return client.GetDatabase(dbt).HashSet(TableName, dataKey, json);
        }
    }
    /// <summary>
    /// Hash 存储一个数据 
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="dataKey"></param>
    /// <param name="db"></param>
    /// <param name="t"></param>
    /// <returns></returns>
    public static bool HashSet(string TableName, string dataKey, int db, RedisValue t)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).HashSet(TableName, dataKey, t);
        }
    }
    #endregion

    #region Hash一次性插入多条数据
    /// <summary>
    /// Hash一次性插入多条数据 数据类型 List<HashEntry> t
    /// </summary>
    /// <param name="key"></param>
    /// <param name="v"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static bool HashSetMore(RedisKey key, List<HashEntry> t, int db)
    {
        using (var connect = ConnectionMultiplexer.Connect(constrStack))
        {
            connect.GetDatabase(db).HashSet(key, t.ToArray());
            return true;
        }
    }
    /// <summary>
    /// hash一次性插入多条数据，数据类型 HashEntry[] v
    /// </summary>
    /// <param name="key"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static bool HashSetMore(RedisKey key, HashEntry[] v, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            client.GetDatabase(db).HashSet(key, v);
            return true;
        }
    }

    #endregion

    #region 从hash中获取单个数据
    /// <summary>
    /// 从hash中获取数据 数据类型T
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="dataKey"></param>
    /// <param name="dbt"></param>
    /// <returns></returns>
    public static T HashGet<T>(string TableName, string dataKey, int dbt)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            string value = client.GetDatabase(dbt).HashGet(TableName, dataKey);
            return RedisHelper.ConvertObj<T>(value);
        }
    }
    /// <summary>
    /// 从hash中获取数据
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="dataKey"></param>
    /// <param name="dbt"></param>
    /// <returns></returns>
    public static string HashGet(string TableName, string dataKey, int dbt)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            string value = client.GetDatabase(dbt).HashGet(TableName, dataKey);
            return value;
        }
    }
    #endregion

    #region 从hash中获取多个键值
    /// <summary> 
    /// 从hash中获取多个键值 返回 RedisValue[]
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="hashFields">一个键值的数组</param>
    /// <param name="dbt"></param>
    /// <returns></returns>
    public static RedisValue[] HashValues(string TableName, RedisValue[] hashFields, int dbt)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(dbt).HashGet(TableName, hashFields);
        }
    }
    /// <summary>
    /// 从hash中获取多个键值 返回List<T>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static List<T> HashValues<T>(RedisKey key, RedisValue[] v, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            var value = client.GetDatabase(db).HashGet(key, v);
            return RedisHelper.ConvetList<T>(value);
        }
    }
    #endregion

    #region 获取整个hash的数据
    /// <summary>
    /// 获取hash表中的所有值   适用于数据量小
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="dbt"></param>
    /// <returns></returns>
    public static HashEntry[] Hash_GetAll(string TableName, int dbt)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(dbt).HashGetAll(TableName);
        }
    }


    #endregion

    #region 获取整个hash的Key 
    /// <summary>
    /// 获取整个hash的Key
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="dataKey"></param>
    /// <param name="dbt"></param>
    /// <returns></returns>
    public static RedisValue[] HashAllKeys(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).HashKeys(TableName);
        }
    }
    #endregion

    #region 获取整个hash的Value
    /// <summary>
    /// 获取整个hash的Value 返回RedisValue[]
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static RedisValue[] HashAllValues(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).HashValues(TableName);
        }
    }
    /// <summary>
    /// 获取整个hash的Value 返回List<T>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static List<T> HashAllValues<T>(RedisKey key, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            RedisValue[] v = client.GetDatabase(db).HashValues(key);
            return RedisHelper.ConvetList<T>(v);
        }
    }
    #endregion

    #region 移除hash中的某个值
    /// <summary>
    /// 移除hash中的某个值
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="dataKey"></param>
    /// <param name="dbt"></param>
    /// <returns></returns>
    public static bool HashDelete(string TableName, string dataKey, int dbt)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(dbt).HashDelete(TableName, dataKey);
        }
    }
    #endregion

    #region 移除hash中多个值
    /// <summary>
    /// 移除hash中多个值
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="dataKey"></param>
    /// <param name="dbt"></param>
    /// <returns></returns>
    public static long HashDelete(string TableName, List<RedisValue> dataKey, int dbt)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(dbt).HashDelete(TableName, dataKey.ToArray());
        }
    }

    public static long HashDelete(string TableName, RedisValue[] Rvalue, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).HashDelete(TableName, Rvalue);
        }
    }
    #endregion

    #region 为数字增长 V
    /// <summary>
    /// 为数字增长 V
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="dataKey"></param>
    /// <param name="dbt"></param>
    /// <param name="v">可以是负数</param>
    /// <returns></returns>
    public static double HashIncrement(string TableName, string dataKey, int dbt, double v = 1)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(dbt).HashIncrement(TableName, dataKey, v);
        }
    }
    #endregion

    #region 为数字减少 V
    /// <summary>
    /// 为数字减少 V
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="dataKey"></param>
    /// <param name="dbt"></param>
    /// <param name="v">可以是负数</param>
    /// <returns></returns>
    public static double HashDecrement(string TableName, string dataKey, int dbt, double v = 1)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(dbt).HashDecrement(TableName, dataKey, v);
        }
    }
    #endregion

    #region 返回hash中的长度
    /// <summary>
    /// 返回hash中的长度
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="key"></param>
    /// <param name="dbt"></param>
    /// <returns></returns>
    public static long HashLength(string TableName, string key, int dbt)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(dbt).HashLength(TableName);
        }
    }
    #endregion

    #endregion

    #region redis数据类型为list

    #region 从key的list中取出所有的数据
    /// <summary>
    /// 从key的list中取出所有的数据
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns>并且数据结构为JSON格式</returns>
    public static List<T> ListRange<T>(string TableName, int db)
    {
        //实例
        //List<JsonObject> li = new List<JsonObject>();
        //li = RedisHelperUtil.ListRange<JsonObject>("abc", 3);
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return RedisHelper.ConvetList<T>(client.GetDatabase(db).ListRange(TableName));
        }
    }

    public static List<T> ListRange<T>(string TableName, int db,int start,int stop)
    {
        //实例
        //List<JsonObject> li = new List<JsonObject>();
        //li = RedisHelperUtil.ListRange<JsonObject>("abc", 3);
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return RedisHelper.ConvetList<T>(client.GetDatabase(db).ListRange(TableName,start,stop));
        }
    }

    /// <summary>
    /// 从key的list中取出所有的数据
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static RedisValue[] ListRange(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListRange(TableName);
        }
    }

    public static RedisValue[] ListRange(RedisKey key, int db, long start, long stop)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListRange(key, start, stop);
        }
    }
    #endregion

    #region 从左侧(头部)向list中添加一个值
    /// <summary>
    /// 从左侧向list中添加一个值(无格式类型)，返回集合总数 
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="value"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListLeftPush(string TableName, RedisValue value, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListLeftPush(TableName, value);
        }
    }
    /// <summary>
    /// 从左侧向list中添加一个值(JSON格式)，返回集合总数 
    /// </summary>
    /// <typeparam name="T">实体</typeparam>
    /// <param name="TableName"></param>
    /// <param name="value"></param>
    /// <param name="db"></param>
    /// <returns>插入数据的表的数据结构要一致并且数据结构为JSON格式</returns>

    public static long ListLeftPush<T>(string TableName, T t, int db)
    {
        string JsonStr = JsonHelperUtil.ConvertJson(t);
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListLeftPush(TableName, JsonStr);
        }
    }

    #endregion

    #region 从左侧（头部）向list中添加多个值
    /// <summary>
    /// 从左侧（头部）向list中添加多个值
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListLeftPush(string TableName, RedisValue[] v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListLeftPush(TableName, v);
        }
    }

    /// <summary>
    /// 从左侧向list中添加多个值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="values"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListLeftPush<T>(string TableName, List<T> values, int db)
    {
        //事例：
        //List<string> tt = new List<string>();
        //tt.Add("a1");
        //tt.Add("a2");
        //tt.Add("a3");
        //var r = RedisHelperUtil.ListLeftPush(tab, tt, dbt);
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            RedisValue[] valueList = RedisHelper.ConvertRedisValue(values.ToArray());
            return client.GetDatabase(db).ListLeftPush(TableName, valueList);
        }
    }
    #endregion

    #region 从右侧（尾部）向list添加一个值
    /// <summary>
    /// 从右侧（尾部）向list添加一个值(无格式)
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="value"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListRightPush(string TableName, RedisValue value, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListRightPush(TableName, value);
        }
    }
    /// <summary>
    /// 从右侧（尾部）向list添加一个值(JSON格式)
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListRightPush<T>(string TableName, T t, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            var v = RedisHelper.ConvertJson(t);
            return client.GetDatabase(db).ListRightPush(TableName, v);
        }
    }

    #endregion

    #region 从右侧（尾部）向list添加多个值

    public static long ListRightPush(string TableName, RedisValue[] v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListRightPush(TableName, v);
        }
    }
    /// <summary>
    /// 从右侧（尾部）向list添加多个值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListRightPush<T>(string TableName, List<T> t, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            RedisValue[] values = RedisHelper.ConvertRedisValue(t.ToArray());
            return client.GetDatabase(db).ListRightPush(TableName, values);
        }
    }

    #endregion

    #region 从左侧(头部)向list中取出一个值 并且删除
    /// <summary>
    /// 从左侧(头部)向list中取出一个值 并且删除
    /// </summary>
    /// <param name="TableNme"></param>
    /// <param name="db"></param>
    /// <returns>返回一个值</returns>
    public static RedisValue ListLeftPop(string TableNme, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return (client.GetDatabase(db).ListLeftPop(TableNme));
        }
    }
    /// <summary>
    /// /// <summary>
    /// 从左侧(头部)向list中取出一个值 返回对象
    /// </summary>
    /// <param name="TableNme"></param>
    /// <param name="db"></param>
    /// <returns>返回一个对象</returns>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static T ListLeftPop<T>(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return RedisHelper.ConvertObj<T>(client.GetDatabase(db).ListLeftPop(TableName));
        }
    }
    #endregion

    #region 从右侧（尾部）向list中取出一个值并且删除

    /// <summary>
    /// 从右侧（尾部）向list中取出一个值并且删除
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static RedisValue ListRightPop(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListRightPop(TableName);
        }
    }
    /// <summary>
    /// 从右侧（尾部）向list中取出一个值 返回对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static T ListRightPop<T>(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return RedisHelper.ConvertObj<T>(client.GetDatabase(db).ListRightPop(TableName));
        }
    }
    #endregion

    #region 从在xx之后入列
    /// <summary>
    /// 从在xx之后(右侧尾部)入列
    /// </summary>
    /// <param name="TableName">表名</param>
    /// <param name="pivot">在pivot之后插入</param>
    /// <param name="v">插入值为v</param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListInsertAfter(string TableName, RedisValue pivot, RedisValue v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListInsertAfter(TableName, pivot, v);
        }
    }

    public static long ListInsertAfter<T>(RedisKey key, RedisValue pivot, T t, int db) 
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack)) 
        {
            return client.GetDatabase(db).ListInsertAfter(key, pivot, RedisHelper.ConvertJson<T>(t));
        }
    }
    #endregion

    #region 从在xx之前入列
    /// <summary>
    /// 从在xx之前入列
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="pivot">在pivot前面插入（左侧。前方）</param>
    /// <param name="v">插入v</param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListInsertBefore(string TableName, RedisValue pivot, RedisValue v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListInsertBefore(TableName, pivot, v);
        }
    }
    public static long ListInsertBefore<T>(string TableName, RedisValue pivot,T t, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListInsertBefore(TableName, pivot, RedisHelper.ConvertJson<T>(t));
        }
    }
    #endregion

    #region 从第几个后面入列
    /// <summary>
    /// 从第几个后面入列
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="index"></param>
    /// <param name="value"></param>
    /// <param name="db"></param>
    public static void ListSetByIndex(string TableName, long index, RedisValue value, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            client.GetDatabase(db).ListSetByIndex(TableName, index, value);
        }
    }
    #endregion

    #region 根据index获取(下标0开始)
    /// <summary>
    /// 根据index获取(下标0开始)
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="index"></param>
    /// <param name="db"></param>
    public static RedisValue ListGetByIndex(string TableName, long index, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListGetByIndex(TableName, index);
        }
    }
    #endregion

    #region list集合长度
    /// <summary>
    /// 返回list集合长度
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListLength(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListLength(TableName);
        }
    }
    #endregion

    #region 从key的List中移除指定的值，返回删除个数
    /// <summary>
    /// 从key的List中移除指定的值，返回删除个数
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long ListRemove(string TableName, RedisValue v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).ListRemove(TableName, v);
        }
    }
    #endregion
    #endregion

    #region redis数据类型为set

    #region 在key集合中添加一个value值
    /// <summary>
    /// 在key集合中添加一个value值
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static bool SetAdd(string TableName, RedisValue v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SetAdd(TableName, v);
        }
    }

    #endregion

    #region 在key集合中添加多个value值
    /// <summary>
    /// 在key集合中添加一个或多个value值
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long SetAdd(string TableName, RedisValue[] v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SetAdd(TableName, v);
        }
    }

    #endregion

    #region 获取Key所有值的集合
    /// <summary>
    /// 获取Key所有值的集合
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static RedisValue[] SetMembers(string TableName, int db)
    {
        #region 实例 :
        //RedisValue[] r = RedisHelperUtil.SetMembers("SetV", 3);
        //var rr = r[1];
        #endregion
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SetMembers(TableName);
        }
    }
    #endregion

    #region 获取key集合的数量
    /// <summary>
    /// 获取key集合的数量
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long SetLength(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SetLength(TableName);
        }
    }
    #endregion

    #region 判断Key集合中是否包含指定的值
    /// <summary>
    /// 判断Key集合中是否包含指定的值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    /// 
    public static bool SetContains(string TableName, RedisValue v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SetContains(TableName, v);
        }
    }
    #endregion

    #region 删除key集合中指定的value
    /// <summary>
    /// 删除key集合中指定的value
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="datakey"></param>
    /// <param name="db"></param>
    public static bool SetRemove(string TableName, string datakey, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SetRemove(TableName, datakey);
        }
    }
    #endregion



    #endregion

    #region redis数据类型为SortedSet

    #region 添加一个值到Key
    /// <summary>
    /// 添加一个值到Key
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="t"></param>
    /// <param name="score"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static bool SortedSetAdd<T>(string TableName, T t, double score, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetAdd(TableName, RedisHelper.ConvertJson<T>(t), score);
        }
    }
    /// <summary>
    /// 添加一个或多个值
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="v"></param>
    /// <param name="score"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long SortedSetAdd(string TableName, SortedSetEntry[] v, double score, int db)
    {
        //实例：
        //SortedSetEntry[] v = {new SortedSetEntry("a",2),new SortedSetEntry("b",2)};
        //var l = RedisHelperUtil.SortedSetAdd("SortedOne",v,2,3);
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetAdd(TableName, v);
        }
    }
    #endregion

    #region 添加一个集合到Key

    /// <summary>
    /// 添加一个集合到Key
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="value"></param>
    /// <param name="score"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long SortedSetAdd<T>(string TableName, List<T> value, double score, int db)
    {
        #region 实例
        //List<string> l = new List<string>();
        //l.Add("aa");
        //l.Add("bb");
        //var t = RedisHelperUtil.SortedSetAdd<string>("Test", l, 2, 3);
        #endregion
        SortedSetEntry[] Svalue = value.Select(o => new SortedSetEntry(RedisHelper.ConvertJson<T>(o), score)).ToArray();
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetAdd(TableName, Svalue);
        }
    }
    #endregion

    #region 获取SortedSet的全部数据 或者从start开始到stop条的数据
    /// <summary>
    /// 获取SortedSet的全部数据
    /// 或者从start开始到stop条的数据
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <param name="start">起始数</param>
    /// <param name="stop">-1表示到结束，0为1条</param>
    /// <param name="desc">是否按降序排列</param>
    /// <returns></returns>
    public static RedisValue[] SortedSetRangeByRankAll(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetRangeByRank(TableName);
        }
    }
    public static RedisValue[] SortedSetRangeByRankAll(string TableName, int db, long start = 0, long stop = -1, bool desc = false)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            start = start == 0 ? 0 : start;
            stop = stop == -1 ? -1 : stop;
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            return client.GetDatabase(db).SortedSetRangeByRank(TableName, start, stop, orderBy);
        }
    }
    #endregion

    #region 获取SortedSet的分页数据
    /// <summary>
    /// 获取SortedSet的分页数据
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="pageIndex">页码</param>
    /// <param name="pageSize">页大小</param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static RedisValue[] SortedSetRangeByRank(string TableName, int pageIndex, int pageSize, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetRangeByRank(TableName, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);
        }
    }
    #endregion

    #region 获取指定key的排序Score值
    /// <summary>
    /// 获取制定key的排序Score值
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="TableName"></param>
    /// <param name="t"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static double? SortedSetScore(string TableName, RedisValue v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetScore(TableName, v);
        }
    }

    public static double? SortedSetScore<T>(string TableName, T t, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetScore(TableName, RedisHelper.ConvertJson<T>(t));
        }
    }



    #endregion

    #region 获取集合中的数量
    /// <summary>
    /// 获取集合中的数量
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long SortedSetLength(string TableName, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetLength(TableName);
        }
    }
    #endregion

    #region 移除数据从SortedSet
    /// <summary>
    /// 移除数据从SortedSet
    /// </summary>
    /// <param name="TableName"></param>
    /// <param name="v"></param>
    /// <param name="db"></param>
    /// <returns></returns>
    public static long SortedSetRemove(string TableName, RedisValue[] v, int db)
    {
        using (var client = ConnectionMultiplexer.Connect(constrStack))
        {
            return client.GetDatabase(db).SortedSetRemove(TableName, v);
        }
    }
    #endregion

    #endregion

}