#使用 StackExchange.Redis 封装 RedisHelper

最新推荐文章于 2024-10-11 10:27:17 发布
最新推荐文章于 2024-10-11 10:27:17 发布
阅读量3.5k 收藏 9
点赞数 1
分类专栏： Redis 文章标签： redis

公司一直在用.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，没事好研究研究。这里我只封装了对缓存的操作，以后可能会更新其他的。

先说说我的想法：

1.定义ICache接口。

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

3.CacheHelper的实现。

上代码：

ICache.cs

复制代码 
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);
    }
}
复制代码

 

Redis.cs

复制代码 
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);
        }
     
    }
}
复制代码

 

CacheHelper.cs

复制代码 
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);
        }

    }
}
复制代码

代码下载

原文地址：https://www.cnblogs.com/itmu89/p/7118474.html                    

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

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

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配置

复制代码 
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>
复制代码

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

则生成两个Hash key 

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

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


如何用10步搞定ASP.NET Core实战中的StackExchange.Redis安装与使用？
java专栏
09-12 839
在文件中添加Redis的连接字符串，以便在应用中方便地访问它。
StackExchange.redis 封装帮助类
chenlianxiang_Blog
04-11 1274
using ModelLibrary.quotedata; using Newtonsoft.Json; using StackExchange.Redis; using System; using System.Collections.Generic; using System.Configuration; using System.Data; using System.Diagnostics;...
StackExchange.Redis
10-20
支持连接不同服务器的redis，同一个redis下能访问不同的库
使用 StackExchange.Redis 在 C# 中开始使用 Redis
最新发布
weixin_46598480的博客
10-11 805
Redis（Remote Dictionary Server）是一个开源的、内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。Redis 支持多种类型的数据结构，如字符串（strings）、哈希表（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）与位图（bitmaps）、超日志（hyperloglogs）和地理空间（geospatial）索引半径查询等。
使用 StackExchange.Redis库实现的 RedisHelper帮助类
CoffeMilk的博客
06-05 2732
一、实现效果
使用 StackExchange.Redis 封装 RedisHelper
技术分享博客
12-29 986
RedisHelper ICache 缓存接口 public interface ICache { /// <summary> /// 缓存过期时间 /// </summary> int TimeOut { set; get; } /// <summary> /// 获得指定键的缓存值 /// </summary> ///
StackExchange.Redis帮助类解决方案RedisRepository封装（散列Hash类型数据操作）
weixin_46020146的博客
05-22 93
StackExchange.Redis帮助类解决方案RedisRepository封装（散列Hash类型数据操作）
StackExchange.Redis 官方文档(四) KeysScan
aunmhiq5181的博客
11-24 194
KEYS, SCAN, FLUSHDB 方法在哪？ 经常有人问这些问题： 好像并没有看到 Keys(...) 或者 Scan(...)方法？那我要怎么查询数据库里面存有哪些key？ 或者 好像没有Flush(...)方法？那我要怎么清除数据库里面的所有key? 问题的关键就在这里：数据库。因为StackExchange.Redis旨在cluster等场景，知道哪些命令的目标是da...
C# StackExchange.Redis 操作封装类库
05-20
C# StackExchange.Redis 操作封装类库，分别封装了Redis五大数据结构（String，Hash，List，Set，ZSet）的增删改查的操作方法，支持Async异步操作。​支持Redis分库操作。支持信息队列操作。 带有单元测试，为每个...
csredis封装_[C#] 使用 StackExchange.Redis 封装属于自己的 RedisHelper
weixin_39911998的博客
12-21 752
目前 .NET 使用访问 Redis 的的类库主流应该是StackExchange.Redis，自己参考网上的文章(也许是吃饱了撑着)，也尝试做出简单的封装。/// /// Redis 助手/// public class RedisHelper{/// /// 连接字符串/// private static readonly string ConnectionString;/// /// re...
StackExchange.Redis helper访问类封装
arefp02662的专栏
06-24 146
　　最近c#项目中遇到图片读取的性能问题，公司的技术总监推荐使用redis来存储。为什么想到用redis来存储: 　　　　第一:每张图片不大,都是10-30kb左右一张。 　　　　第二:一个项目的图片数量多,一个项目有20-30张图片，并且图片存储在一个专门的图片站点要求要1秒内把图片下载到本地 第三:可以把图片转base64字符串存储到redis中 ...
StackExchange.Redis.dll
04-02
最近需要在C#中使用Redis，ServiceStack.Redis的4.0版本已开始收费，之前版本Bug较多。建议使用StackExchange.Redis，支持异步的客户端，据说性能比ServiceStack.Redis更好，而且据说Stack Overflow也是使用的这个客户端，现在果断换了这个，发上来免得大家找得辛苦，与大家分享。
StackExchange.Redis Redis客户端
07-20
最近需要在C#中使用Redis，在Redis的官网找到了ServiceStack.Redis，最后在测试的时候发现这是个坑，4.0已上已经收费，后面只好找到3系列的最终版本，最后测试发现还是有BUG或者是我不会用。没有办法，最好找到了StackExchange.Redis，支持异步的客户端，据说性能比ServiceStack.Redis更好，而且据说Stack Overflow也是使用的这个客户端，现在果断换了这个，发上来免得大家找得辛苦，里面有支持4.0和4.5的版本。
详解StackExchange.Redis通用封装类分享
08-31
主要介绍了详解StackExchange.Redis通用封装类分享 ，详细的介绍了StackExchange.Redis通用封装，具有一定的参考价值，有需要的可以了解一下。
C#操作redis（StackExchange.Redis）
zhiqingcn的专栏
04-20 4106
C#操作redis入门步骤：安装redis–安装可视化软件RedisDesktopManager–C#操作redis前两步软件的安装教程很多，这里不赘述。一、类库的选择在C#中使用Redis，一般有两种方式：1、ServiceStack.Redis，据说是Redis官方推荐使用的驱动类库，但是是收费的。2、StackExchange.Redis，可能性能要比ServiceStack.Redis差点，但是是免费的。
c#使用 StackExchange.Redis 封装 RedisHelper
Qin066的博客
06-04 4109
公司一直在用.net自带的缓存，大家都知道.net自带缓存的缺点，就不多说了，不知道的可以查一查，领导最近在说分布式缓存，我们选的是redis，领导让我不忙的时候封装一下，搜索了两天，选了选第三方的插件，ServiceStack.Redis和StackExchange.Redis以前都用过，不过都是别人封装好的，今天在往项目中整合的时候，我使用的ServiceStack.Redis版本不兼容.ne...
C#使用StackExchange.Redis连接Redis数据库
qq_36437991的博客
02-28 616
c#连接redis数据库，并且指定数据库和密码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值