使用 StackExchange.Redis 封装 RedisHelper

RedisHelper

ICache 缓存接口

 public interface ICache
    {
        /// <summary>
        /// 缓存过期时间
        /// </summary>
        int TimeOut { set; get; }
        /// <summary>
        /// 获得指定键的缓存值
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <returns>缓存值</returns>
        object Get(string key);
        /// <summary>
        /// 获得指定键的缓存值
        /// </summary>
        T Get<T>(string key);
        /// <summary>
        /// 从缓存中移除指定键的缓存值
        /// </summary>
        /// <param name="key">缓存键</param>
        void Remove(string key);
        /// <summary>
        /// 清空所有缓存对象
        /// </summary>
        //void Clear();
        /// <summary>
        /// 将指定键的对象添加到缓存中
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        void Insert(string key, object data);
        /// <summary>
        /// 将指定键的对象添加到缓存中
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        void Insert<T>(string key, T data);
        /// <summary>
        /// 将指定键的对象添加到缓存中，并指定过期时间
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        /// <param name="cacheTime">缓存过期时间(秒钟)</param>
        void Insert(string key, object data, int cacheTime);

        /// <summary>
        /// 将指定键的对象添加到缓存中，并指定过期时间
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        /// <param name="cacheTime">缓存过期时间(秒钟)</param>
        void Insert<T>(string key, T data, int cacheTime);
        /// <summary>
        /// 将指定键的对象添加到缓存中，并指定过期时间
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        /// <param name="cacheTime">缓存过期时间</param>
        void Insert(string key, object data, DateTime cacheTime);
        /// <summary>
        /// 将指定键的对象添加到缓存中，并指定过期时间
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        /// <param name="cacheTime">缓存过期时间</param>
        void Insert<T>(string key, T data, DateTime cacheTime);
        /// <summary>
        /// 判断key是否存在
        /// </summary>
        bool Exists(string key);
        /// <summary>
        /// 右侧入队
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        long EnqueueListRightPush(RedisKey queueName, RedisValue redisValue);
        /// <summary>
        /// 左侧入队
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="redisvalue"></param>
        /// <returns></returns>
        long EnqueueListLeftPush(RedisKey queueName, RedisValue redisvalue);
        /// <summary>
        /// 获取队列长度
        /// </summary>
        /// <param name="queueName"></param>
        /// <returns></returns>
        long EnqueueListLength(RedisKey queueName);
        /// <summary>
        /// 左侧出队
        /// </summary>
        /// <param name="queueName"></param>
        /// <returns></returns>
        string DequeueListPopLeft(RedisKey queueName);
        /// <summary>
        /// 右侧出队
        /// </summary>
        /// <param name="queueName"></param>
        /// <returns></returns>
        string DequeueListPopRight(RedisKey queueName);
        /// <summary>
        /// 分布式加锁
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="data">值</param>
        /// <param name="seconds">过期时间</param>
        /// <returns></returns>
        bool LockTake(string key, string data, TimeSpan seconds, int db = 0);
        /// <summary>
        /// 解锁
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="data">值</param>
        /// <returns></returns>
        bool LockRelease(string key, string data, int db = -1);
    }

Redis 类
要注意这里的入队和出队，若你使用的是左侧入队那么后面取数据的话要用左侧出队去取出。如果你使用左侧入队用右侧出队去取出数据的话，那么他取到的是最新放入队列的数据

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Web;

namespace WX_Card.CardUtility.RedisHelper
{
//实现缓存接口
    public class Redis : ICache
    {
        int Default_Timeout = 600;//默认超时时间（单位秒）
        string address;
        JsonSerializerSettings jsonConfig = new JsonSerializerSettings() { ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore, NullValueHandling = NullValueHandling.Ignore };
        ConnectionMultiplexer connectionMultiplexer;
        IDatabase database;

        class CacheObject<T>
        {
            public int ExpireTime { get; set; }
            public bool ForceOutofDate { get; set; }
            public T Value { get; set; }
        }

        public Redis(int dbbase=0)
        {
            this.address = "127.0.0.1:6379,password=123456";

            if (this.address == null || string.IsNullOrWhiteSpace(this.address.ToString()))
                throw new ApplicationException("配置文件中未找到RedisServer的有效配置");
            connectionMultiplexer = ConnectionMultiplexer.Connect(address);
             connectionMultiplexer.ConnectionFailed += (sender, args) =>
 {
    //redis断开重连
     connectionMultiplexer = ConnectionMultiplexer.Connect(address);
 };
            database = connectionMultiplexer.GetDatabase(dbbase);
        }

        /// <summary>
        /// 连接超时设置
        /// </summary>
        public int TimeOut
        {
            get
            {
                return Default_Timeout;
            }
            set
            {
                Default_Timeout = value;
            }
        }

        public object Get(string key)
        {
            return Get<object>(key);
        }

        public T Get<T>(string key)
        {

            DateTime begin = DateTime.Now;
            var cacheValue = database.StringGet(key);
            DateTime endCache = DateTime.Now;
            var value = default(T);
            if (!cacheValue.IsNull)
            {
                var cacheObject = JsonConvert.DeserializeObject<CacheObject<T>>(cacheValue, jsonConfig);
                if (!cacheObject.ForceOutofDate)
                    database.KeyExpire(key, new TimeSpan(0, 0, cacheObject.ExpireTime));
                value = cacheObject.Value;
            }
            DateTime endJson = DateTime.Now;
            return value;

        }

        public void Insert(string key, object data)
        {
            var jsonData = GetJsonData(data, TimeOut, false);
            database.StringSet(key, jsonData);
        }

        public void Insert(string key, object data, int cacheTime)
        {
            var timeSpan = TimeSpan.FromSeconds(cacheTime);
            var jsonData = GetJsonData(data, TimeOut, true);
            database.StringSet(key, jsonData, timeSpan);
        }

        public void Insert(string key, object data, DateTime cacheTime)
        {
            var timeSpan = cacheTime - DateTime.Now;
            var jsonData = GetJsonData(data, TimeOut, true);
            database.StringSet(key, jsonData, timeSpan);
        }

        public void Insert<T>(string key, T data)
        {
            var jsonData = GetJsonData<T>(data, TimeOut, false);
            database.StringSet(key, jsonData);
        }

        public void Insert<T>(string key, T data, int cacheTime)
        {
            var timeSpan = TimeSpan.FromSeconds(cacheTime);
            var jsonData = GetJsonData<T>(data, TimeOut, true);
            database.StringSet(key, jsonData, timeSpan);
        }

        public void Insert<T>(string key, T data, DateTime cacheTime)
        {
            var timeSpan = cacheTime - DateTime.Now;
            var jsonData = GetJsonData<T>(data, TimeOut, true);
            database.StringSet(key, jsonData, timeSpan);
        }


        string GetJsonData(object data, int cacheTime, bool forceOutOfDate)
        {
            var cacheObject = new CacheObject<object>() { Value = data, ExpireTime = cacheTime, ForceOutofDate = forceOutOfDate };
            return JsonConvert.SerializeObject(cacheObject, jsonConfig);//序列化对象
        }

        string GetJsonData<T>(T data, int cacheTime, bool forceOutOfDate)
        {
            var cacheObject = new CacheObject<T>() { Value = data, ExpireTime = cacheTime, ForceOutofDate = forceOutOfDate };
            return JsonConvert.SerializeObject(cacheObject, jsonConfig);//序列化对象
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="key"></param>
        public void Remove(string key)
        {
            database.KeyDelete(key, CommandFlags.HighPriority);
        }

        /// <summary>
        /// 判断key是否存在
        /// </summary>
        public bool Exists(string key)
        {
            return database.KeyExists(key);
        }
        /// <summary>
        /// 右侧入队
        /// </summary>
        /// <param name="queueName">队列名称</param>
        /// <param name="redisValue">值</param>
        /// <returns></returns>
        public long EnqueueListRightPush(RedisKey queueName, RedisValue redisValue)
        {
            return database.ListRightPush(queueName, redisValue);
        }
        /// <summary>
        /// 左侧入队
        /// </summary>
        /// <param name="queueName">队列名称</param>
        /// <param name="redisvalue">队列值</param>
        /// <returns></returns>
        public long EnqueueListLeftPush(RedisKey queueName, RedisValue redisvalue)
        {
            return database.ListLeftPush(queueName, redisvalue);
        }
        /// <summary>
        /// 获取队列长度
        /// </summary>
        /// <param name="queueName">队列名称</param>
        /// <returns></returns>
        public long EnqueueListLength(RedisKey queueName)
        {
            if(database.KeyExists(queueName))
            {
                return database.ListLength(queueName);
            }
            else
            {
                return 0;
            }
           
        }
        /// <summary>
        /// 左侧出队
        /// </summary>
        /// <param name="queueName"></param>
        /// <returns></returns>
        public string DequeueListPopLeft(RedisKey queueName)
        {
            int count = database.ListRange(queueName).Length;
            if (count > 0)
            {
                string redisValue = database.ListLeftPop(queueName);
                if (!string.IsNullOrEmpty(redisValue))
                    return redisValue;
                else
                    return string.Empty;
            }
            else
            {
                return "-1";
                throw new Exception($"队列{queueName}数据为零");
            }
        }

        public string DequeueListPopRight(RedisKey queueName)
        {
            int count = database.ListRange(queueName).Length;
            if (count > 0)
            {
                string redisValue = database.ListRightPop(queueName);
                if (!string.IsNullOrEmpty(redisValue))
                    return redisValue;
                else
                    return string.Empty;
            }
            else
            {
                return "-1";
                throw new Exception($"队列{queueName}数据为零");
            }
        }
    }
}

CacheHelper类

    /// <summary>
    /// 缓存
    /// </summary>
    public static class RedisHelper
    {
        private static object cacheLocker = new object();//缓存锁对象
        private static ICache cache = null;//缓存接口

        static RedisHelper()
        {
            Load();
        }

         /// <summary>
        /// 指定数据库
        /// </summary>
        /// <param name="database"></param>
       public static void Init(int database)
        {
            Load(database);
        }
        /// <summary>
        /// 加载缓存
        /// </summary>
        /// <exception cref=""></exception>
        private static void Load(int Default=0)
        {
            try
            {
                cache = new Redis(Default);
            }
            catch (Exception ex)
            {
                //Log.Error(ex.Message);
            }
        }

        public static ICache GetCache()
        {
            return cache;
        }


        /// <summary>
        /// 缓存过期时间
        /// </summary>
        public static int TimeOut
        {
            get
            {
                return cache.TimeOut;
            }
            set
            {
                lock (cacheLocker)
                {
                    cache.TimeOut = value;
                }
            }
        }

        /// <summary>
        /// 获得指定键的缓存值
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <returns>缓存值</returns>
        public static object Get(string key)
        {
            if (string.IsNullOrWhiteSpace(key))
                return null;
            return cache.Get(key);
        }

        /// <summary>
        /// 获得指定键的缓存值
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <returns>缓存值</returns>
        public static T Get<T>(string key)
        {
            return cache.Get<T>(key);
        }

        /// <summary>
        /// 将指定键的对象添加到缓存中
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        public static void Insert(string key, object data)
        {
            if (string.IsNullOrWhiteSpace(key) || data == null)
                return;
            //lock (cacheLocker)
            {
                cache.Insert(key, data);
            }
        }
        /// <summary>
        /// 将指定键的对象添加到缓存中
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        public static void Insert<T>(string key, T data)
        {
            if (string.IsNullOrWhiteSpace(key) || data == null)
                return;
            //lock (cacheLocker)
            {
                cache.Insert<T>(key, data);
            }
        }
        /// <summary>
        /// 将指定键的对象添加到缓存中，并指定过期时间
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        /// <param name="cacheTime">缓存过期时间(分钟)</param>
        public static void Insert(string key, object data, int cacheTime)
        {
            if (!string.IsNullOrWhiteSpace(key) && data != null)
            {
                //lock (cacheLocker)
                {
                    cache.Insert(key, data, cacheTime);
                }
            }
        }

        /// <summary>
        /// 将指定键的对象添加到缓存中，并指定过期时间
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        /// <param name="cacheTime">缓存过期时间(分钟)</param>
        public static void Insert<T>(string key, T data, int cacheTime)
        {
            if (!string.IsNullOrWhiteSpace(key) && data != null)
            {
                //lock (cacheLocker)
                {
                    cache.Insert<T>(key, data, cacheTime);
                }
            }
        }

        /// <summary>
        /// 将指定键的对象添加到缓存中，并指定过期时间
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        /// <param name="cacheTime">缓存过期时间</param>
        public static void Insert(string key, object data, DateTime cacheTime)
        {
            if (!string.IsNullOrWhiteSpace(key) && data != null)
            {
                //lock (cacheLocker)
                {
                    cache.Insert(key, data, cacheTime);
                }
            }
        }

        /// <summary>
        /// 将指定键的对象添加到缓存中，并指定过期时间
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <param name="data">缓存值</param>
        /// <param name="cacheTime">缓存过期时间</param>
        public static void Insert<T>(string key, T data, DateTime cacheTime)
        {
            if (!string.IsNullOrWhiteSpace(key) && data != null)
            {
                //lock (cacheLocker)
                {
                    cache.Insert<T>(key, data, cacheTime);
                }
            }
        }

        /// <summary>
        /// 从缓存中移除指定键的缓存值
        /// </summary>
        /// <param name="key">缓存键</param>
        public static void Remove(string key)
        {
            if (string.IsNullOrWhiteSpace(key))
                return;
            lock (cacheLocker)
            {
                cache.Remove(key);
            }
        }

        /// <summary>
        /// 判断key是否存在
        /// </summary>
        public static bool Exists(string key)
        {
            return cache.Exists(key);
        }
		  /// <summary>
        /// 右侧入队
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public static long EnqueueListRightPush(RedisKey queueName, RedisValue redisValue)
        {
            return cache.EnqueueListLeftPush(queueName, redisValue);
        }
        /// <summary>
        /// 左侧入队
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="redisvalue"></param>
        /// <returns></returns>
        public static long EnqueueListLeftPush(RedisKey queueName, RedisValue redisvalue)
        {
            return cache.EnqueueListLeftPush(queueName, redisvalue);
        }
        /// <summary>
        /// 获取队列长度
        /// </summary>
        /// <param name="queueName"></param>
        /// <returns></returns>
        public static long EnqueueListLength(RedisKey queueName)
        {
            return cache.EnqueueListLength(queueName);
        }
        /// <summary>
        /// 左侧出队
        /// </summary>
        /// <param name="queueName"></param>
        /// <returns></returns>
        public static string DequeueListPopLeft(RedisKey queueName)
        {
            return cache.DequeueListPopLeft(queueName);
        }
        /// <summary>
        /// 右侧出队
        /// </summary>
        /// <param name="queueName"></param>
        /// <returns></returns>
       public static string DequeueListPopRight(RedisKey queueName)
        {
            return cache.DequeueListPopRight(queueName);
        }
        /// <summary>
        /// 分布式加锁，如果锁定成功，就去执行方法
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="data">值</param>
        /// <param name="seconds">锁过期时间</param>
        /// <returns></returns>
        public static bool LockTake(string key, string data, TimeSpan seconds, int db = -1)
        {
            return cache.LockTake(key,data,seconds, db);
        }
        public static bool LockRelease(string key, string data, int db = -1)
        {
            return cache.LockRelease(key, data, db);
        }

    }

webconfig类里定义连接字符串

  <add key="RedisServer" value="127.0.0.1:6379,password=123456"/>