#使用 StackExchange.Redis 封装 RedisHelper

阳光穿透心脏的1/2处 2022-05-23 04:56 199阅读 0赞

公司一直在用.net自带的缓存，大家都知道.net自带缓存的缺点，就不多说了，不知道的可以查一查，领导最近在说分布式缓存，我们选的是redis，领导让我不忙的时候封装一下，搜索了两天，选了选第三方的插件，ServiceStack.Redis和StackExchange.Redis以前都用过，不过都是别人封装好的，今天在往项目中整合的时候，我使用的ServiceStack.Redis版本不兼容.net 4.0，在网上找了一圈，ServiceStack.Redis对.net 4.0的支持用起来很麻烦，要改变系统引用的东西，最后放弃了，今天又拿NServiceKit.Redis重新封装了一下，下一篇在说NServiceKit.Redis。先说说ServiceStack.Redis，ServiceStack.Redis是Redis官方推荐的C\#客户端，性能非常优越，使用也很方便，但是从v4版本已经逐渐商业化了，普通版每小时只能访问Redis 6000次，我没测试过，大家可以看看这篇文章http://blog.csdn.net/u010533180/article/details/52856586，所以我放弃了ServiceStack.Redis，选择了StackExchange.Redis，StackExchange.Redis也是开源的，这是地址：https://github.com/StackExchange/StackExchange.Redis，我使用的是.net 4.5，工具采用 vs2015， StackExchange.Redis版本是1.0.488。

对于与Redis连接的配置写法很简单，最简单的写法写个IP和端口就可以了，如你有其他想法自己去查资料吧。StackExchange.Redis中的核心是ConnectionMultiplexer，没事好研究研究。这里我只封装了对缓存的操作，以后可能会更新其他的。

先说说我的想法：

![709254-20170704204341925-1100815794.png][]

1.定义ICache接口。

2.Redis类和Memcached类，以后想用那个缓存修改一下配置就可以了，非常方便。

3.CacheHelper的实现。

上代码：

ICache.cs

![复制代码][copycode.gif]

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Common
    {
        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);
        }
    }

![复制代码][copycode.gif]

Redis.cs

![复制代码][copycode.gif]

using Newtonsoft.Json;
    using StackExchange.Redis;
    using System;
    using System.Collections.Generic;
    using System.Configuration;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Common
    {
        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()
            {
                this.address = ConfigurationManager.AppSettings["RedisServer"];
    
                if (this.address == null || string.IsNullOrWhiteSpace(this.address.ToString()))
                    throw new ApplicationException("配置文件中未找到RedisServer的有效配置");
                connectionMultiplexer = ConnectionMultiplexer.Connect(address);
                database = connectionMultiplexer.GetDatabase();
            }
    
            /// <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);
            }
         
        }
    }

![复制代码][copycode.gif]

CacheHelper.cs

![复制代码][copycode.gif]

using System;
    using System.Collections.Generic;
    
    namespace Common
    {
        /// <summary>
        /// 缓存
        /// </summary>
        public static class Cache
        {
            private static object cacheLocker = new object();//缓存锁对象
            private static ICache cache = null;//缓存接口
            
            static Cache()
            {
                Load();
            }
    
            /// <summary>
            /// 加载缓存
            /// </summary>
            /// <exception cref=""></exception>
            private static void Load()
            {
                try
                {
                   cache = new Redis();
                }
                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);
            }
    
        }
    }

![复制代码][copycode.gif]

[代码下载][Link 1]

原文地址：[https://www.cnblogs.com/itmu89/p/7118474.html    ][https_www.cnblogs.com_itmu89_p_7118474.html_ _]

分类:  [Redis][]

[Redis和StackExchange.Redis][Redis_StackExchange.Redis]

redis有多个数据库  
1、redis 中的每一个数据库，都由一个 redisDb 的结构存储。其中，redisDb.id 存储着 redis 数据库以整数表示的号码。redisDb.dict 存储着该库所有的键值对数据。redisDb.expires 保存着每一个键的过期时间。

2、当redis 服务器初始化时，会预先分配 16 个数据库（该数量可以通过配置文件配置），所有数据库保存到结构 redisServer 的一个成员 redisServer.db 数组中。当我们选择数据库 select number 时，程序直接通过 redisServer.db\[number\] 来切换数据库。有时候当程序需要知道自己是在哪个数据库时，直接读取 redisDb.id 即可。

![614863-20160821131701167-1066355412.png][]

3、既然我们知道一个数据库的所有键值都存储在redisDb.dict中，那么我们要知道如果找到key的位置，redis 的字典使用哈希表作为其底层实现。

StackExchange.Redis,肯定少不了提一下ServiceStack.Redis,这两个都是redis在c\#里面比较优秀的SDk.

ServiceStack.Redis 4 开始已经收费了,所以你懂的.StackOverflow他们在开发并使用StackExchange.Redis

我想可能微软也看见了它的"厉害",所以在微软官方出的RedisSessionStateProvider中也是采用的StackExchange.Redis来实现的

# StackExchange.Redis实现Session #

使用Nuget安装RedisSessionStateProvider,sessionState的模式默认有Custom,InProc,Off,SQLServer,StateServer这五种,默认的就是InProc,也就是我们常用的进程内Session.使用自定义的Session实现肯定就要选Custom模式了.

Web.config配置

![复制代码][copycode.gif 1]

1  <sessionState mode="Custom" customProvider="MySessionStateStore">
    2       <providers>
    3         <add name="MySessionStateStore" type="Microsoft.Web.Redis.RedisSessionStateProvider" connectionString="ip:端口,password=密码,ssl=false,abortConnect=false,connectTimeout=5000"/>
    4       </providers>
    5  </sessionState>

![复制代码][copycode.gif 1]

如在代码中使用 Session\["redissession"\] = "sa";

则生成两个Hash key

![614863-20160821133608448-2001100283.png][]

其中wmhe4v0zvbbfinkdnckutv4l就是ASP.NET\_SessionId,通过监视请求也可以看见

![614863-20160821134514401-11626328.png][]

StackExchange.Redis可以实现Redis所有命令,常用操作查看[https://github.com/StackExchange/StackExchange.Redis][https_github.com_StackExchange_StackExchange.Redis]

[709254-20170704204341925-1100815794.png]: /images/20220523/a8ac540286114a52bd5ea2d8a9da2de8.png
[copycode.gif]: /images/20220523/785001eb486c4c979c1f67dcc9200c06.png
[Link 1]: http://files.cnblogs.com/files/itmu89/StackExchange.Redis.zip
[https_www.cnblogs.com_itmu89_p_7118474.html_ _]: https://www.cnblogs.com/itmu89/p/7118474.html
[Redis]: http://www.cnblogs.com/itmu89/category/1028986.html
[Redis_StackExchange.Redis]: https://www.cnblogs.com/zxtceq/p/7680641.html
[614863-20160821131701167-1066355412.png]: /images/20220523/b13f32032b754907b71be80ac501fcd4.png
[copycode.gif 1]: /images/20220523/1f76cb24605948898c42a50b5b12af65.png
[614863-20160821133608448-2001100283.png]: /images/20220523/ceadffeb4d3f464fac14fac1e1cdc3ca.png
[614863-20160821134514401-11626328.png]: /images/20220523/3ff62d2382ed4eca826938c37d2de438.png
[https_github.com_StackExchange_StackExchange.Redis]: https://github.com/StackExchange/StackExchange.Redis