StackExchange.Redis 访问封装类优化

最新推荐文章于 2024-09-10 09:42:16 发布
最新推荐文章于 2024-09-10 09:42:16 发布
阅读量571 收藏 1
点赞数
分类专栏： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a22698488/article/details/102486138
版权 
/// 在StackExchange.Redis中最重要的对象是ConnectionMultiplexer类， 它存在于StackExchange.Redis命名空间中。
/// 这个类隐藏了Redis服务的操作细节，ConnectionMultiplexer类做了很多东西， 在所有调用之间它被设计为共享和重用的。
/// 不应该为每一个操作都创建一个ConnectionMultiplexer 。 ConnectionMultiplexer是线程安全的 ， 推荐使用下面的方法。
/// 在所有后续示例中 ， 都假定你已经实例化好了一个ConnectionMultiplexer类，它将会一直被重用 ，
/// 现在我们来创建一个ConnectionMultiplexer实例。它是通过ConnectionMultiplexer.Connect 或者 ConnectionMultiplexer.ConnectAsync，
/// 传递一个连接字符串或者一个ConfigurationOptions 对象来创建的。
/// 连接字符串可以是以逗号分割的多个服务的节点.
/// 
/// 
/// 注意 : 
/// ConnectionMultiplexer 实现了IDisposable接口当我们不再需要是可以将其释放的 , 这里我故意不使用 using 来释放他。 
/// 简单来讲创建一个ConnectionMultiplexer是十分昂贵的 ， 一个好的主意是我们一直重用一个ConnectionMultiplexer对象。
/// 一个复杂的的场景中可能包含有主从复制 ， 对于这种情况，只需要指定所有地址在连接字符串中（它将会自动识别出主服务器）
///  ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("server1:6379,server2:6379");
/// 假设这里找到了两台主服务器，将会对两台服务进行裁决选出一台作为主服务器来解决这个问题 ， 这种情况是非常罕见的 ，我们也应该避免这种情况的发生。
/// 
/// 
/// 这里有个和 ServiceStack.Redis 大的区别是没有默认的连接池管理了。没有连接池自然有其利弊,最大的好处在于等待获取连接的等待时间没有了,
/// 也不会因为连接池里面的连接由于没有正确释放等原因导致无限等待而处于死锁状态。缺点在于一些低质量的代码可能导致服务器资源耗尽。不过提供连接池等阻塞和等待的手段是和作者的设计理念相违背的。StackExchange.Redis这里使用管道和多路复用的技术来实现减少连接
/// 
using StackExchange.Redis;
using System;
using System.IO;
using System.Net;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace BN.Data
{
    public static class RedisCacheHelper
    {
        private static readonly string Coonstr = System.Configuration.ConfigurationManager.AppSettings["redis"];
        private static object _locker = new Object();
        private static ConnectionMultiplexer _instance = null;
        /// <summary>
        /// 使用一个静态属性来返回已连接的实例，如下列中所示。这样，一旦 ConnectionMultiplexer 断开连接，便可以初始化新的连接实例。
        /// </summary>
        public static ConnectionMultiplexer Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_locker)
                    {
                        if (_instance == null || !_instance.IsConnected)
                        {
                            _instance = ConnectionMultiplexer.Connect(Coonstr);
                        }
                    }
                }
                //注册如下事件
                _instance.ConnectionFailed += MuxerConnectionFailed;
                _instance.ConnectionRestored += MuxerConnectionRestored;
                _instance.ErrorMessage += MuxerErrorMessage;
                _instance.ConfigurationChanged += MuxerConfigurationChanged;
                _instance.HashSlotMoved += MuxerHashSlotMoved;
                _instance.InternalError += MuxerInternalError;
                return _instance;
            }
        }
        static RedisCacheHelper()
        {
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public static IDatabase GetDatabase()
        {
            return Instance.GetDatabase();
        }

        /// <summary>
        /// 这里的 MergeKey 用来拼接 Key 的前缀，具体不同的业务模块使用不同的前缀。默认最多缓存一天
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        private static string MergeKey(string key)
        {
            //第一步,添加前缀
            System.Text.StringBuilder sb = new System.Text.StringBuilder();

            var redis_prefix = System.Configuration.ConfigurationManager.AppSettings["redis_prefix"];
            if (string.IsNullOrEmpty(redis_prefix))
            {
                sb.Append(AppDomain.CurrentDomain.BaseDirectory);
            }
            else
            {
                sb.Append(redis_prefix);
            }

            //第二步:去掉key中的空字符等
            MatchCollection results = Regex.Matches(key, "\\S");

            foreach (var v in results)
            {
                sb.Append(v.ToString());
            }

            //第三步,添加一天的限制
            if (!string.IsNullOrEmpty(key))
            {
                sb.Append(DateTime.Now.ToString("yyyyMMdd"));
            }

            return System.Web.HttpUtility.UrlEncode(sb.ToString()).ToLower();
        }
        /// <summary>
        /// 根据key获取缓存对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public static T Get<T>(string key)
        {
            key = MergeKey(key);
            return Deserialize<T>(GetDatabase().StringGet(key));
        }
        /// <summary>
        /// 根据key获取缓存对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static object Get(string key)
        {
            key = MergeKey(key);
            return Deserialize<object>(GetDatabase().StringGet(key));
        }

        /// <summary>
        /// 设置缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static void Set(string key, object value)
        {
            key = MergeKey(key);
            GetDatabase().StringSet(key, Serialize(value));
        }

        /// <summary>
        /// 设置缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static void Set(string key, object value, int cacheTime)
        {
            key = MergeKey(key);
            GetDatabase().StringSet(key, Serialize(value), TimeSpan.FromSeconds(cacheTime));
        }


        /// <summary>
        /// 判断在缓存中是否存在该key的缓存数据
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool Exists(string key)
        {
            key = MergeKey(key);
            return GetDatabase().KeyExists(key);  //可直接调用
        }

        /// <summary>
        /// 移除指定key的缓存
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool Remove(string key)
        {
            key = MergeKey(key);
            return GetDatabase().KeyDelete(key);
        }


        public static void RemoveAll()
        {
            var pattern = $"{MergeKey("")}*";

            GetDatabase().ScriptEvaluate(LuaScript.Prepare(
                //Redis的keys模糊查询：
                " local ks = redis.call('KEYS', @keypattern) " + //local ks为定义一个局部变量，其中用于存储获取到的keys
                " for i=1,#ks,5000 do " +    //#ks为ks集合的个数, 语句的意思： for(int i = 1; i <= ks.Count; i+=5000)
                "     redis.call('del', unpack(ks, i, math.min(i+4999, #ks))) " + //Lua集合索引值从1为起始，unpack为解包，获取ks集合中的数据，每次5000，然后执行删除
                " end " +
                " return true "
                ),
                new { keypattern = pattern });
        }


        /// <summary>
        /// 异步设置
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static async Task SetAsync(string key, object value)
        {
            key = MergeKey(key);
            await GetDatabase().StringSetAsync(key, Serialize(value));
        }

        /// <summary>
        /// 根据key获取缓存对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static async Task<object> GetAsync(string key)
        {
            key = MergeKey(key);
            object value = await GetDatabase().StringGetAsync(key);
            return value;
        }

        /// <summary>
        /// 实现递增
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static long Increment(string key)
        {
            key = MergeKey(key);
            //三种命令模式
            //Sync,同步模式会直接阻塞调用者，但是显然不会阻塞其他线程。
            //Async,异步模式直接走的是Task模型。
            //Fire - and - Forget,就是发送命令，然后完全不关心最终什么时候完成命令操作。
            //即发即弃：通过配置 CommandFlags 来实现即发即弃功能，在该实例中该方法会立即返回，如果是string则返回null 如果是int则返回0.这个操作将会继续在后台运行，一个典型的用法页面计数器的实现：
            return GetDatabase().StringIncrement(key, flags: CommandFlags.FireAndForget);
        }

        /// <summary>
        /// 实现递减
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static long Decrement(string key, string value)
        {
            key = MergeKey(key);
            return GetDatabase().HashDecrement(key, value, flags: CommandFlags.FireAndForget);
        }

        /// <summary>
        /// 序列化对象
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        private static byte[] Serialize(object o)
        {
            if (o == null)
            {
                return null;
            }
            BinaryFormatter binaryFormatter = new BinaryFormatter();
            using (MemoryStream memoryStream = new MemoryStream())
            {
                binaryFormatter.Serialize(memoryStream, o);
                byte[] objectDataAsStream = memoryStream.ToArray();
                return objectDataAsStream;
            }
        }

        /// <summary>
        /// 反序列化对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="stream"></param>
        /// <returns></returns>
        private static T Deserialize<T>(byte[] stream)
        {
            if (stream == null)
            {
                return default(T);
            }
            BinaryFormatter binaryFormatter = new BinaryFormatter();
            using (MemoryStream memoryStream = new MemoryStream(stream))
            {
                T result = (T)binaryFormatter.Deserialize(memoryStream);
                return result;
            }
        }
        /// <summary>
        /// 配置更改时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
        {
            LogHelper.Debug("Configuration changed: " + e.EndPoint);
        }
        /// <summary>
        /// 发生错误时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
            LogHelper.Debug("ErrorMessage: " + e.Message);
        }
        /// <summary>
        /// 重新建立连接之前的错误
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            LogHelper.Debug("ConnectionRestored: " + e.EndPoint);
        }
        /// <summary>
        /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            LogHelper.Debug("重新连接：Endpoint failed: " + e.EndPoint + ", " + e.FailureType + (e.Exception == null ? "" : (", " + e.Exception.Message)));
        }
        /// <summary>
        /// 更改集群
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            LogHelper.Debug("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
        }
        /// <summary>
        /// redis类库错误
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
            LogHelper.Debug("InternalError:Message" + e.Exception.Message);
        }

        //场景不一样，选择的模式便会不一样，大家可以按照自己系统架构情况合理选择长连接还是Lazy。
        //建立连接后，通过调用ConnectionMultiplexer.GetDatabase 方法返回对 Redis Cache 数据库的引用。从 GetDatabase 方法返回的对象是一个轻量级直通对象，不需要进行存储。

        /// <summary>
        /// 使用的是Lazy，在真正需要连接时创建连接。
        /// 延迟加载技术
        /// 微软azure中的配置 连接模板
        /// </summary>
        //private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        //{
        //    //var options = ConfigurationOptions.Parse(constr);
        //    options.ClientName = GetAppName(); // only known at runtime
        //    //options.AllowAdmin = true;
        //    //return ConnectionMultiplexer.Connect(options);
        //    ConnectionMultiplexer muxer = ConnectionMultiplexer.Connect(Coonstr);
        //    muxer.ConnectionFailed += MuxerConnectionFailed;
        //    muxer.ConnectionRestored += MuxerConnectionRestored;
        //    muxer.ErrorMessage += MuxerErrorMessage;
        //    muxer.ConfigurationChanged += MuxerConfigurationChanged;
        //    muxer.HashSlotMoved += MuxerHashSlotMoved;
        //    muxer.InternalError += MuxerInternalError;
        //    return muxer;
        //});


        #region  当作消息代理中间件使用 一般使用更专业的消息队列来处理这种业务场景
        /// <summary>
        /// 当作消息代理中间件使用
        /// 消息组建中,重要的概念便是生产者,消费者,消息中间件。
        /// </summary>
        /// <param name="channel"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public static long Publish(string channel, string message)
        {
            ISubscriber sub = Instance.GetSubscriber();
            //return sub.Publish("messages", "hello");
            return sub.Publish(channel, message);
        }

        /// <summary>
        /// 在消费者端得到该消息并输出
        /// </summary>
        /// <param name="channelFrom"></param>
        /// <returns></returns>
        public static void Subscribe(string channelFrom)
        {
            ISubscriber sub = Instance.GetSubscriber();
            sub.Subscribe(channelFrom, (channel, message) =>
            {
                Console.WriteLine((string)message);
            });
        }
        #endregion

        /// <summary>
        /// GetServer方法会接收一个EndPoint类或者一个唯一标识一台服务器的键值对
        /// 有时候需要为单个服务器指定特定的命令
        /// 使用IServer可以使用所有的shell命令，比如：
        /// DateTime lastSave = server.LastSave();
        /// ClientInfo[] clients = server.ClientList();
        /// 如果报错在连接字符串后加 ,allowAdmin=true;
        /// </summary>
        /// <returns></returns>
        public static IServer GetServer(string host, int port)
        {
            IServer server = Instance.GetServer(host, port);
            return server;
        }

        /// <summary>
        /// 获取全部终结点
        /// </summary>
        /// <returns></returns>
        public static EndPoint[] GetEndPoints()
        {
            EndPoint[] endpoints = Instance.GetEndPoints();
            return endpoints;
        }

    }
}

原文:https://www.cnblogs.com/hnsongbiao/p/5414728.html

xiaonibaba
关注
专栏目录
如何用10步搞定ASP.NET Core实战中的StackExchange.Redis安装与使用？
java专栏
09-12 838
在文件中添加Redis的连接字符串，以便在应用中方便地访问它。
[外包]!采用asp.net core 快速构建小型创业公司后台管理系统(三.Redis优化,StackExchange.Redis没毛病)...
11-22 317
本章主要说一下Redis Redis操作优化 一.基础类的配置工作 　　1.我想信许多人（许多neter人）操作redis依然用的是StackExchange.Redis，这个neget包，并没有用国内现在一些大佬们推出了包 　　 　　RedisOptions主要是redis连接的一个配置类 　　实现代码如下： public class RedisOptions...
StackExchange.Redis 访问封装类
weixin_34014555的博客
12-23 182
最近需要在C#中使用Redis，在Redis的官网找到了ServiceStack.Redis，最后在测试的时候发现这是个坑，4.0已上已经收费，后面只好找到3系列的最终版本，最后测试发现还是有BUG或者是我不会用。没有办法，最好找到了StackExchange.Redis，支持异步的客户端，据说性能比ServiceStack.Redis更好，而且据说Stack Overflow也是使用的这个客户端...
StackExchange.Redis.Extensions: 开启Redis操作的高效之旅
最新发布
gitblog_01025的博客
09-10 299
StackExchange.Redis.Extensions: 开启Redis操作的高效之旅 StackExchange.Redis.Extensions项目地址:https://gitcode.com/gh_mirrors/st/StackExchange.Redis.Extensions 在当今高速发展的软件行业中，数据存储和快速访问成为众多开发者面临的挑战之一。而Redis，作为一个高性能...
StackExchange.Redis官方文档(一)【基本用法】
极客神殿
10-30 9245
基本用法ConnectionMultiplexer 类是StackExchange.Redis的中枢对象，它在StackExchange.Redis名称空间中； 这个对象封装了很多基础服务对象的详细信息。由于 ConnectionMultiplexer 做了很多底层处理，它在调用者之间被设计为共享和重用。你不应该为每一个操作都创建一个 ConnectionMultiplexer 对象。该对象是完全
Redis（二）分布式锁与Redis集群搭建
好好学习，天天向上！
04-02 1425
文章目录一、 线程锁与分布式锁二、Redis集群 一、 线程锁与分布式锁 线程锁 单体项目 单体项目 步骤 代码如下 //定义静态全局锁 private readonly static object _lock = new object(); // 控制器中添加代码 lock (_lock) { Stock sto = new Stock(); sto = demoDbContext.stock.Where(p => p.ID == 1).FirstOrDef
详解StackExchange.Redis通用封装类分享
08-31
为了解决这个问题，你可以编写详细的API文档和示例，分享封装类的设计和使用，这对于其他开发者来说具有很大的参考价值。 总之，StackExchange.Redis的封装旨在简化和优化其使用，提高代码的可读性和可维护性，同时...
.net core使用redis基于StackExchange.Redis
10-19
为了便于管理和复用Redis操作，我们可以创建一个封装类，比如RedisClient。该类实现IDisposable接口，以确保资源得到正确释放。在这个封装类中，我们可以维护一个ConcurrentDictionary集合，用于缓存每个Redis实例的...
StackExchange.Redis通用封装深度解析与实战
本文将详细介绍StackExchange.Redis的通用封装类，这是一种在.NET中广泛使用的Redis客户端库。StackExchange.Redis提供了与Redis数据库的高效交互，但在使用过程中，由于其官方文档相对较少，尤其是在中文资源方面，...
Redis_C#21.rar
09-24
7. **封装库**：为了简化开发，通常会创建一个自定义的 Redis 客户端类，封装常用的操作方法。这样可以统一错误处理、日志记录和连接管理，提高代码的可读性和可维护性。示例中可能就包含这样的封装。 8. **性能...
c#连接Redis的安装与配置和例子
06-27
Redis是一个不错的缓存数据库，读取数据速度效率都很不错。今天大家共同研究下redis的用法。结合网上的资料和自己的摸索，先来看下安装与配置把。 咱们主要看在WINDOWS上怎样使用REDIS数据库。 主要是C#语言
StackExchange.Redis 使用资料
haxinet的博客
03-18 9385
在StackExchange.Redis中最重要的对象是ConnectionMultiplexer类， 它存在于StackExchange.Redis命名空间中。 这个类隐藏了Redis服务的操作细节，ConnectionMultiplexer类做了很多东西， 在所有调用之间它被设计为共享和重用的。 不应该为每一个操作都创建一个ConnectionMultiplexer 。 Connectio
【C#与Redis】--高级主题--Redis 发布订阅
喵叔
12-27 1677
发布订阅（Publish-Subscribe）是一种消息传递模式，用于在软件系统中实现解耦和灵活的组件通信。在发布订阅模式中，消息的发送者（发布者）并不直接将消息发送给特定的接收者（订阅者），而是将消息发送到一个中心化的调度机制，通常称为消息代理或主题（topic）。订阅者可以通过订阅特定的主题来接收感兴趣的消息，从而实现了解耦和松散耦合的通信方式。负责产生并发布消息的组件或模块。发布者将消息发送到消息代理而不关心谁订阅了这些消息。感兴趣并订阅特定主题的组件或模块。
缓存中间件-Redis(二)
www_xuhss_com的博客
04-15 938
Python微信订餐小程序课程视频 https://blog.csdn.net/m0_56069948/article/details/122285951 Python实战量化交易理财系统 https://blog.csdn.net/m0_56069948/article/details/122285941 在上一篇中我们简单总结和介绍了Redis的几个方面 1.使用Redis背景 2.Redis通信多路复用的基本原理 3.Redis基本数据结构 4.Redis持久化方式 这一篇我们使用简单
StackExchange.Redis性能调优
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
07-29 2476
点击上方“程序员大咖”，选择“置顶公众号”关键时刻，第一时间送达！来源：彭伟文：cnblogs.com/qhca/p/9347604.html程序员大咖整理发布，转载请联...
StackExchange.Redis 官方文档(一) Basics
aunmhiq5181的博客
10-27 219
基本使用方法： StackExchange.Redis的核心是 StackExchange.Redis 命名空间的 ConnectionMultiplexer 类;它隐藏了多服务器的实现细节.ConnectionMultiplexer被设计成可以在多个客户端之间分享和复用.不用每次操作都创建一个对象实例.对于这种使用方式，它是足够的线程安全和完备的.以后所有的示例都会假设已经创建了一个 ...
使用StackExchange.Redis操作Redis--配置
热门推荐
学习的路上，永不停止
04-13 1万+
1、最简单的配置var conn = ConnectionMultiplexer.Connect("localhost");在不指定端口号的情况下，默认6379端口；附加选项只是简单的附件（逗号分隔）。端口常用冒号（:）表示。例如var conn = ConnectionMultiplexer.Connect("redis0:6380,redis1:6380,allowAdmin=true");通...
StackExchange.Redis的基本使用
飞翔的学习笔记
03-17 1万+
StackExchange.Redis是一款免费的操作Redis的客户端工具，我们使用这个库来简单的学习下Redis的一些基本操作 Redis默认安装好后的端口是6379 密码可以自己设置，使用命令修改 config get requirepass //获取当前密码 config set requirepass "yourpassword"//设置当前密码 代码里需引用StackExch...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值