RedisCacheHelper

    public class RedisCacheHelper
    {
        ////默認緩存過期時間單位秒
        public static int secondsTimeOut = 30 * 60;
        // 數據庫
        public static long InitialDb;
        // 地址
        public static string Url;
        private static PooledRedisClientManager _instance = null;
        private static object _locker = new Object();


        /// <summary>
        /// Redis連接池管理
        /// </summary>
        public static PooledRedisClientManager Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_locker)
                    {
                        if (_instance == null)
                        {
                            InitialDb = 8;
                            Url = "127.0.0.1";
                            _instance = new PooledRedisClientManager(InitialDb, new string[] { Url });
                        }
                    }
                }
                return _instance;
            }
        }
        static RedisCacheHelper()
        {
        }

        /// <summary>
        /// 連接Redis
        /// </summary>
        /// <returns></returns>
        public static RedisClient GetClient()
        {
            return (RedisClient)Instance.GetClient();
        }

        #region Key/Value讀取和存儲
        /// <summary>
        /// 添加新緩存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="t"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public static bool Add<T>(string key, T t, int timeout)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                if (timeout > 0)
                {
                    secondsTimeOut = timeout;
                }
                return redisClient.Add<T>(key, t, DateTime.Now.AddHours(secondsTimeOut));
            }
        }
        /// <summary>
        /// 添加新緩存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="t"></param>
        /// <param name="timeSpan"></param>
        /// <returns></returns>
        public static bool Add<T>(string key, T t, TimeSpan timeSpan)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.Add<T>(key, t, timeSpan);
            }
        }

        /// <summary>
        /// 設置緩存 用於修改
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key">緩存建</param>
        /// <param name="t">緩存值</param>
        /// <param name="timeout">過期時間，單位秒,-1：不過期，0：默認過期時間</param>
        /// <returns></returns>
        public static bool Set<T>(string key, T t, int timeout = 0)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                if (timeout > 0)
                {
                    secondsTimeOut = timeout;
                }
                return redisClient.Set<T>(key, t, DateTime.Now.AddHours(secondsTimeOut));
            }
        }
        /// <summary>
        /// 設置緩存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="t"></param>
        /// <param name="timeSpan"></param>
        /// <returns></returns>
        public static bool Set<T>(string key, T t, TimeSpan timeSpan)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.Set<T>(key, t, timeSpan);
            }
        }


        /// <summary>
        /// 獲取
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public static T Get<T>(string key)
        {
            if (!string.IsNullOrWhiteSpace(key))
            {
                using (var redisClient = RedisCacheHelper.GetClient())
                {
                    return redisClient.Get<T>(key);
                }
            }
            return default(T);
        }


        #endregion

        #region 鏈表操作
        /// <summary>
        /// 獲取鏈表數據
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <returns></returns>
        public static IEnumerable<T> GetList<T>(string listId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                IRedisTypedClient<T> iredisClient = redisClient.As<T>();
                return iredisClient.Lists[listId];
            }
        }

        /// <summary>
        /// IEnumerable數據添加到鏈表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="values"></param>
        /// <param name="timeout"></param>
        public static void AddList<T>(string listId, IEnumerable<T> values, int timeout = 0)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                redisClient.Expire(listId, 60);
                IRedisTypedClient<T> iredisClient = redisClient.As<T>();
                if (timeout >= 0)
                {
                    if (timeout > 0)
                    {
                        secondsTimeOut = timeout;
                    }
                    redisClient.Expire(listId, secondsTimeOut);
                }
                var redisList = iredisClient.Lists[listId];
                redisList.AddRange(values);
                iredisClient.Save();
            }
        }

        /// <summary>
        /// 添加單個實體到鏈表中
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="item"></param>
        /// <param name="timeout"></param>
        public static void AddEntityToList<T>(string listId, T item, int timeout = 0)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                IRedisTypedClient<T> iredisClient = redisClient.As<T>();
                if (timeout >= 0)
                {
                    if (timeout > 0)
                    {
                        secondsTimeOut = timeout;
                    }
                    redisClient.Expire(listId, secondsTimeOut);
                }
                var redisList = iredisClient.Lists[listId];
                redisList.Add(item);
                iredisClient.Save();
            }
        }

        /// <summary>
        /// 在鏈表中刪除單個實體
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="t"></param>
        public static void RemoveEntityFromList<T>(string listId, T t)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                IRedisTypedClient<T> iredisClient = redisClient.As<T>();
                var redisList = iredisClient.Lists[listId];
                redisList.RemoveValue(t);
                iredisClient.Save();
            }
        }

        /// <summary>
        /// 根據lambada表達式刪除符合條件的實體
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="func"></param>
        public static void RemoveEntityFromList<T>(string listId, Func<T, bool> func)
        {
            using (IRedisTypedClient<T> iredisClient = RedisCacheHelper.GetClient().As<T>())
            {
                var redisList = iredisClient.Lists[listId];
                T value = redisList.Where(func).FirstOrDefault();
                redisList.RemoveValue(value);
                iredisClient.Save();
            }
        }


        #endregion

        #region get操作
        /// <summary>
        /// 根據key值獲取value
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string GetValue(string key)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetValue(key);
            }
        }


        /// <summary>
        /// 獲得hash型key某個字段的值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="field"></param>
        public static string GetValueFromHash(string hashId, string key)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                string value = redisClient.GetValueFromHash(hashId, key);
                return value;
            }
        }

        /// <summary>
        /// 判斷hash中是否存在某個key
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool HashContainsEntry(string hashId, string key)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.HashContainsEntry(hashId, key);
            }
        }


        /// <summary>
        /// 判斷某個key是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool ContainsKey(string key)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.ContainsKey(key);
            }
        }


        /// <summary>
        /// 判斷一個Key是否存在Set中
        /// </summary>
        /// <param name="setId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool SortedSetContainsItem(string setId, string value)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.SortedSetContainsItem(setId, value);
            }
        }

        /// <summary>
        /// 獲取hash的數量
        /// </summary>
        /// <param name="hashId"></param>
        /// <returns></returns>
        public static long GetHashCount(string hashId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetHashCount(hashId);
            }
        }

        /// <summary>
        /// 獲取set的數量
        /// </summary>
        /// <param name="setId"></param>
        /// <returns></returns>
        public static long GetSetCount(string setId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetSetCount(setId);
            }
        }

        /// <summary>
        /// 獲取某一個值在set的下標
        /// </summary>
        /// <param name="setId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static long GetItemIndexInSortedSet(string setId, string value)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetItemIndexInSortedSet(setId, value);
            }
        }


        /// <summary>
        /// 獲取SortSet數量
        /// </summary>
        /// <param name="setId"></param>
        /// <returns></returns>
        public static long GetSortedSetCount(string setId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetSortedSetCount(setId);
            }
        }

        /// <summary>
        /// 獲取Set裏的所有數據
        /// </summary>
        /// <param name="setId"></param>
        /// <returns></returns>
        public static HashSet<string> GetAllItemsFromSet(string setId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetAllItemsFromSet(setId);
            }
        }




        /// <summary>
        ///  獲取SortedSet的所有項，按分數倒序
        /// </summary>
        /// <param name="setId"></param>
        /// <returns></returns>
        public static List<string> GetAllItemsFromSortedSetDesc(string setId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetAllItemsFromSortedSetDesc(setId);
            }
        }


        /// <summary>
        ///  獲取SortedSet的所有項
        /// </summary>
        /// <param name="setId"></param>
        /// <returns></returns>
        public static List<string> GetAllItemsFromSortedSet(string setId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetAllItemsFromSortedSet(setId);
            }
        }

        /// <summary>
        /// 獲取SortedSet的分數
        /// </summary>
        /// <param name="setId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static double? GetItemScoreInSortedSet(string setId, string value)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetItemScoreInSortedSet(setId, value);
            }
        }

        /// <summary>
        /// 獲取SortedSet的值和分數
        /// </summary>
        /// <param name="setId"></param>
        /// <returns></returns>
        public static IDictionary<string, double> GetAllWithScoresFromSortedSet(string setId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetAllWithScoresFromSortedSet(setId);
            }
        }


        /// <summary>
        /// 搜key
        /// </summary>
        /// <param name="pattern"></param>
        /// <returns></returns>
        public static List<string> SearchKeys(string pattern)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.SearchKeys(pattern);
            }
        }




        #endregion

        #region Set操作

        /// <summary>
        /// 設置hash型key某個字段的值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="field"></param>
        /// <param name="value"></param>
        public static void SetHashField(string hashId, string key, string value)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                redisClient.SetEntryInHash(hashId, key, value);
            }
        }

        /// <summary>
        /// 插入內容到SortedSet
        /// </summary>
        /// <param name="setId"></param>
        /// <param name="value">值</param>
        /// <param name="score">分數</param>
        /// <returns></returns>
        public static bool AddItemToSortedSet(string setId, string value, double score)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.AddItemToSortedSet(setId, value, score);
            }
        }

        /// <summary>
        /// 插入內容到SortedSet
        /// </summary>
        /// <param name="setId"></param>
        /// <param name="value">值</param>
        /// <returns></returns>
        public static bool AddItemToSortedSet(string setId, string value)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.AddItemToSortedSet(setId, value);
            }
        }

        /// <summary>
        /// 往Set裏寫內容
        /// </summary>
        /// <param name="setId"></param>
        /// <param name="item"></param>
        public static void AddItemToSet(string setId, string item)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                redisClient.AddItemToSet(setId, item);
            }

        }

        /// <summary>
        /// 從SortedSet中取出分數最低的一條記錄
        /// </summary>
        /// <param name="client"></param>
        /// <param name="setId"></param>
        /// <returns></returns>
        public static string PopItemWithLowestScoreFromSortedSet(string setId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.PopItemWithLowestScoreFromSortedSet(setId);
            }
        }

        /// <summary>
        /// 從SortedSet中取出分數最高的一條記錄
        /// </summary>
        /// <param name="setId"></param>
        /// <returns></returns>
        public static string PopItemWithHighestScoreFromSortedSet(string setId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.PopItemWithHighestScoreFromSortedSet(setId);
            }
        }

        /// <summary>
        /// 設置字符串緩存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static void SetEntry(string key, string value)
        {

            using (var redisClient = RedisCacheHelper.GetClient())
            {
                redisClient.SetEntry(key, value);
            }
        }

        /// <summary>
        /// 設置字符串緩存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="timeSpan">過期時間</param>
        public static void SetEntry(string key, string value, TimeSpan timeSpan)
        {

            using (var redisClient = RedisCacheHelper.GetClient())
            {
                redisClient.SetEntry(key, value, timeSpan);
            }
        }

        #endregion

        #region  REMOVE 移除相關命令
        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool Remove(string key)
        {
            if (!string.IsNullOrWhiteSpace(key))
            {
                using (var redisClient = RedisCacheHelper.GetClient())
                {
                    return redisClient.Remove(key);
                }
            }
            return false;
        }


        /// <summary>
        /// 移除Sorted
        /// <param name="setId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool RemoveItemFromSortedSet(string setId, string value)
        {
            if (!string.IsNullOrWhiteSpace(setId) && !string.IsNullOrWhiteSpace(value))
            {
                using (var redisClient = RedisCacheHelper.GetClient())
                {
                    return redisClient.RemoveItemFromSortedSet(setId, value);
                }
            }
            return false;

        }

        /// <summary>
        /// 移除hash中的key
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool RemoveEntryFromHash(string hashId, string key)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.RemoveEntryFromHash(hashId, key);
            }
        }

        /// <summary>
        /// 從Set中移除值
        /// </summary>
        /// <param name="client"></param>
        /// <param name="setId"></param>
        /// <param name="item"></param>
        public static void RemoveItemFromSet(string setId, string item)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                redisClient.RemoveItemFromSet(setId, item);
            }
        }

        #endregion

        #region 判斷

        /// <summary>
        /// 設置某個Key過期
        /// </summary>
        /// <param name="key"></param>
        /// <param name="expireAt"></param>
        /// <returns></returns>
        public static bool ExpireEntryAt(string key, DateTime expireAt)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.ExpireEntryAt(key, expireAt);
            }
        }

        /// <summary>
        /// 設置某個Key過期
        /// </summary>
        /// <param name="key">jian</param>
        /// <param name="expireAt"></param>
        /// <returns></returns>
        public static bool ExpireEntryIn(string key, TimeSpan timeSpan)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.ExpireEntryIn(key, timeSpan);
            }
        }

        #endregion

        #region hash
        /// <summary>
        /// 獲取hash表的key集合
        /// </summary>
        /// <param name="hashId"></param>
        /// <returns></returns>
        public static List<string> GetHashKeys(string hashId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                return redisClient.GetHashKeys(hashId);
            }
        }


        /// <summary>
        /// 獲得某個hash型key下的所有值
        /// </summary>
        /// <param name="hashId"></param>
        /// <returns></returns>
        public static List<string> GetHashValues(string hashId)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                List<string> hashValues = redisClient.GetHashValues(hashId);
                return hashValues;
            }
        }

        /// <summary>
        ///使某個字段增加
        /// </summary>
        /// <param name="key"></param>
        /// <param name="field"></param>
        /// <param name="incre"></param>
        /// <returns></returns>
        public static void SetHashIncr(string key, string field, int incre)
        {
            using (var redisClient = RedisCacheHelper.GetClient())
            {
                redisClient.IncrementValueInHash(key, field, incre);
            }
        }

        #endregion

        #region 重命名
        /// <summary>
        /// 重命名
        /// </summary>
        /// <param name="fromName">之前的名稱</param>
        /// <param name="toName">修改後的名稱</param>
        public static void RenameKey(string fromName, string toName)
        {
            using (var redisClient = GetClient())
            {
                redisClient.RenameKey(fromName, toName);
            }
        }
        #endregion


        #region 清空redis
        /// <summary>
        /// 
        /// </summary>
        /// <param name="noDeleteKeys">不刪的keys</param>
        public static void FlushRedisdb(List<string> noDeleteKeys = null)
        {
            using (var redisClient = GetClient())
            {
                var keys = redisClient.GetAllKeys();
                foreach (string key in keys)
                {
                    if (noDeleteKeys != null && noDeleteKeys.Count > 0 && noDeleteKeys.Contains(key))
                    {
                        //不刪
                    }
                    else
                    {
                        //刪
                        redisClient.Remove(key);
                    }
                }
            }
        }
        #endregion

        #region 按照規則刪除redis歷史數據
        /// <summary>
        /// 按照規則刪除redis歷史數據
        /// </summary>
        /// <param name="foucsday">當日</param>
        /// <param name="IsReserveYesterday">是否要保留當日的昨天數據</param>
        /// <param name="hashId">指定的hashid</param>
        public static void ClearRedisHis(DateTime foucsday, bool IsReserveYesterday = false, string hashId = "")
        {
            string reserveToday = foucsday.ToString("yyyyMMdd");
            string reserveYesterday = foucsday.AddDays(-1).ToString("yyyyMMdd");
            using (var redisClient = GetClient())
            {
                #region 
                if (!string.IsNullOrWhiteSpace(hashId))
                {
                    //按hash刪
                    List<string> keys = redisClient.GetHashKeys(hashId);
                    foreach (var t_key in keys)
                    {
                        if (t_key.Length < 8)
                        {
                            continue;//單號長度太短 
                        }

                        if (IsReserveYesterday)
                        {
                            if (t_key.IndexOf(reserveToday) < 0//不是今天
                              && t_key.IndexOf(reserveYesterday) < 0//也不是昨天
                                )
                            {
                                //移除
                                redisClient.RemoveEntryFromHash(hashId, t_key);
                            }
                        }
                        else
                        {
                            if (t_key.IndexOf(reserveToday) < 0//不是今天
                                 )
                            {
                                //移除
                                redisClient.RemoveEntryFromHash(hashId, t_key);
                            }
                        }

                    }
                }
                else
                {
                    //按key刪除
                    List<string> keys = redisClient.SearchKeys("*");
                    foreach (var t_key in keys)
                    {
                        if (t_key.Length < 8)
                        {
                            continue;//單號長度太短 
                        }

                        if (IsReserveYesterday)
                        {
                            if (t_key.IndexOf(reserveToday) < 0//不是今天
                              && t_key.IndexOf(reserveYesterday) < 0//也不是昨天
                                )
                            {
                                //移除
                                redisClient.Remove(t_key);
                            }
                        }
                        else
                        {
                            if (t_key.IndexOf(reserveToday) < 0//不是今天
                                )
                            {
                                //移除
                                redisClient.Remove(t_key);
                            }
                        }

                    }
                }
                #endregion

            }

        }

        #endregion
    }
    ~~~