redis幫助類

話不多說，上代碼

第一種：多線程安全，線程不是每次都加鎖，按需加載（懶漢模式） 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Net.Http;
using static ConsoleApp1.Program;
using ServiceStack.Redis;
using System.Configuration;
using log4net;

namespace ConsoleApp1
{ 
    public class RedisLearn
    {
        protected static PooledRedisClientManager pooled;
        protected static RedisClient redisClientRead;
        protected static RedisClient redisClientWrite;

        /// <summary>
        /// 程序運行時，創建一個靜態只讀的進程輔助對象
        /// </summary>
        private static readonly object obj = new object();

        private RedisLearn()
        {

        }

        /// <summary>
        /// 獲取Redis寫節點
        /// </summary>
        /// <returns></returns>
        internal static RedisClient GetInstance()
        {
            if (pooled == null)//在同一時刻加了鎖的那部分程序只有一個線程可以進入，實現線程安全

                lock (obj)
                {
                    //如實例不存在，則New一個新實例，否則返回已有實例
                    if (pooled == null)
                    {
                        CreatePoolManager();
                    }
                }
            if (redisClientWrite == null)
            {
                redisClientWrite = pooled.GetClient() as RedisClient;
            }
            return redisClientWrite;

        }


        /// <summary>
        /// 獲取Redis讀節點
        /// </summary>
        /// <returns></returns>
        internal static RedisClient GetReadOnlyInstance()
        {
            if (pooled == null)
            {
                lock (obj)
                {
                    if (pooled == null)
                    {
                        CreatePoolManager();
                    }
                }
            }
            if (redisClientRead == null)
            {
                redisClientRead = pooled.GetReadOnlyClient() as RedisClient;
            }

            return redisClientRead;
        }

        /// <summary>
        /// 創建連接
        /// </summary>
        private static void CreatePoolManager()
        {
            string redisWrite = ConfigurationManager.AppSettings["RedisWrite"].ToString(); //寫節點(主節點)
            List<string> writes = new List<string>();
            writes.Add(redisWrite);

            string redisRead = ConfigurationManager.AppSettings["RedisRead"].ToString();  //讀節點
            List<string> reads = new List<string>();
            reads.Add(redisRead);

            //配置連接池和讀寫分類
            pooled = new PooledRedisClientManager(writes, reads, new RedisClientManagerConfig()
            {
                MaxReadPoolSize = 50, //讀節點個數
                MaxWritePoolSize = 50,//寫節點個數

            });
        }
    }
}

  第二種：靜態初始化，減少開銷

using ServiceStack.Redis;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
   public class RedisLearnHelp
    {
        private static readonly RedisLearnHelp redisLearnHelp = null;
        public static PooledRedisClientManager pooled;

        public static RedisClient redisClientRead;
        public static RedisClient redisClientWrite;

        static RedisLearnHelp()
        {
            redisLearnHelp = new RedisLearnHelp();
        }

        private RedisLearnHelp()
        {

        }

        /// <summary>
        /// 獲取Redis寫節點
        /// </summary>
        /// <returns></returns>
        public static RedisClient GetInstance
        {
            get
            {
                if (pooled == null)
                {
                    CreatePoolManager();
                }
                if (redisClientWrite==null)
                {
                    redisClientWrite = pooled.GetClient() as RedisClient;
                }

                return redisClientWrite;
            }
        }


        /// <summary>
        /// 獲取Redis讀節點
        /// </summary>
        /// <returns></returns>
        public static RedisClient GetReadOnlyInstance
        {
            get
            {
                if (pooled == null)
                {
                    CreatePoolManager();
                }
                if (redisClientRead == null)
                {
                    redisClientRead = pooled.GetReadOnlyClient() as RedisClient;
                }

                return redisClientRead;

            }
        }

        /// <summary>
        /// 創建連接
        /// </summary>
        private static void CreatePoolManager()
        {
            string redisWrite = ConfigurationManager.AppSettings["RedisWrite"].ToString();
            string redisRead = ConfigurationManager.AppSettings["RedisRead"].ToString();
            //寫節點(主節點)
            List<string> writes = new List<string>();
            writes.Add(redisWrite);
            //讀節點
            List<string> reads = new List<string>();
            reads.Add(redisRead);

            //配置連接池和讀寫分類
            pooled = new PooledRedisClientManager(writes, reads, new RedisClientManagerConfig()
            {
                MaxReadPoolSize = 50, //讀節點個數
                MaxWritePoolSize = 50,//寫節點個數

            });
        }
    }
}

 調用方法封裝

using ServiceStack.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using log4net;

namespace ConsoleApp1
{
    public class RedisHelp
    {

        public static readonly log4net.ILog log = LogManager.GetLogger("log4netlogger");

        #region set

        /// <summary>
        /// 保存單個值
        /// </summary>
        /// <param name="key">鍵</param>
        /// <param name="value">值</param>
        /// <param name="expire">過期時間（分鐘）</param>
        /// <param name="connectionMode">數據來源</param>
        public void SetValue(string key, string value, int expire = 30, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);
            redisClient.SetValue(key, value, ConvertTimeSpan(expire));
        }

        /// <summary>
        /// 獲取單個值
        /// </summary>
        /// <param name="key">鍵</param>
        /// <param name="connectionMode"></param>
        /// <returns>值</returns>
        public string GetValue(string key, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);
            return redisClient.GetValue(key);
        }

        /// <summary>
        /// 保存對象
        /// </summary>
        /// <typeparam name="T">對象類型</typeparam>
        /// <param name="key">鍵</param>
        /// <param name="obj">值</param> 
        /// <param name="expire">過期時間</param>
        /// <param name="connectionMode">數據來源</param>
        /// <returns></returns>
        public bool Set(string key, object obj, int expire = 30, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);
            return redisClient.Set(key, obj, ConvertTimeSpan(expire));
        }

        /// <summary>
        /// 根據鍵獲取對象
        /// </summary>
        /// <typeparam name="T">對象類型</typeparam>
        /// <param name="key">鍵</param>
        /// <param name="connectionMode"></param>
        /// <returns></returns>
        public T Get<T>(string key, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);
            return redisClient.Get<T>(key);
        }
        #endregion

        #region Hash

        /// <summary>
        /// 存儲數據到hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="key">鍵</param>
        /// <param name="obj">值</param>
        /// <param name="expire">過期時間</param>
        /// <param name="connectionMode"></param>
        /// <returns></returns>
        public bool SetHash(string hashId, string key, object obj, int expire = 30, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);

            var value = JsonHelper.JsonSerialize(obj);

            redisClient.ExpireEntryIn(key, ConvertTimeSpan(expire));

            return redisClient.SetEntryInHash(hashId, key, value);
        }

        /// <summary>
        /// 從Hash表獲取數據
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="hashId"></param>
        /// <param name="key"></param>
        /// <param name="connectionMode"></param>
        /// <returns></returns>
        public T GetHash<T>(string hashId, string key, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);

            return JsonHelper.JsonDeserialize<T>(redisClient.GetValueFromHash(hashId, key));
        }

        /// <summary>
        /// 存儲多個數據到hash
        /// </summary>
        /// <param name="hashId"></param>
        /// <param name="obj"></param>
        /// <param name="connectionMode"></param>
        public void SetHash(string hashId, List<KeyValuePair<string, string>> obj, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);

            redisClient.SetRangeInHash(hashId, obj);
        }

        /// <summary>
        /// 獲取整個Hash的數據
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="hashId"></param>
        /// <param name="connectionMode"></param>
        /// <returns></returns>
        public List<T> GetAllHash<T>(string hashId, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);

            var value = new List<T>();

            var list = redisClient.GetHashValues(hashId);
            if (list != null && list.Count > 0)
            {
                foreach (var item in list)
                {
                    value.Add(JsonHelper.JsonDeserialize<T>(item));
                }
            }

            return value;
        }


        /// <summary>
        /// 移除hash中的某值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="hashId"></param>
        /// <param name="key"></param>
        /// <param name="connectionMode"></param>
        /// <returns></returns>
        public bool RemoveHash<T>(string hashId, string key, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);

            return redisClient.RemoveEntryFromHash(hashId, key);
        }

        #endregion

        /// <summary>
        /// 根據鍵移除  /移除整個hash
        /// </summary>
        /// <param name="key">鍵</param>
        /// <param name="connectionMode"></param>
        /// <returns></returns>
        public bool Remove(string key, EConnectionMode connectionMode = EConnectionMode.Read)
        {
            RedisClient redisClient = GetClient(connectionMode);
            return redisClient.Remove(key);
        }

        #region 公共幫助類

        /// <summary>                                                                                                                                                                                                                               
        /// 轉換時間爲timespan格式
        /// </summary>
        /// <param name="expire">間隔時間(分鐘)</param>
        /// <returns></returns>
        private TimeSpan ConvertTimeSpan(int expire)
        {
            return TimeSpan.FromMinutes(expire);
        }

        /// <summary>
        /// 獲取RedisClient
        /// </summary>
        /// <param name="connectionMode"></param>
        /// <returns></returns>
        private RedisClient GetClient(EConnectionMode connectionMode)
        {
            return connectionMode == EConnectionMode.Write ? RedisLearn.GetInstance() : RedisLearn.GetReadOnlyInstance();

        }

        //private static RedisClient GetClient(EConnectionMode connectionMode)
        //{
        //    return connectionMode == EConnectionMode.Write ? RedisLearnHelp.GetInstance : RedisLearnHelp.GetReadOnlyInstance;
        //}

        #endregion
    }
    public enum EConnectionMode
    {
        Read = 1,
        Write = 2
    }

    public class JsonHelper
    {
        /// <summary>
        /// 將對象轉換爲json串
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string JsonSerialize(object obj)
        {
            return JsonConvert.SerializeObject(obj);
        }

        /// <summary>
        /// 將json串轉換爲對象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="json"></param>
        /// <returns></returns>
        public static T JsonDeserialize<T>(string json)
        {
            if (string.IsNullOrEmpty(json))
                return System.Activator.CreateInstance<T>();

            return JsonConvert.DeserializeObject<T>(json);
        }
    }

}