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);
        }
    }

}