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

}