.NetCore使用Redis，StackExchange.Redis队列，发布与订阅，分布式锁的简单使用

最新推荐文章于 2024-05-29 14:28:20 发布
最新推荐文章于 2024-05-29 14:28:20 发布
阅读量2.1k 收藏 12
点赞数 1
文章标签： 网络 分布式 redis 数据库 多线程

https://www.cnblogs.com/Fengge518/p/13556182.html

环境：之前一直是使用serverStack.Redis的客服端，

今天来使用一下StackExchange.Redis(个人感觉更加的人性化一些，也是免费的，性能也不会差太多)，
版本为StackExchange.Redis V2.1.58 ,Core3.1

简单的说明(专业的术语参考资料网络和官网)：官网地址：https://www.redis.net.cn/

Redis（Remote Dictionary Server )，即远程字典服务是一个开源的 ，由C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

Redis 是一个高性能的key-value数据库。Redis的出现，很大程度补偿了memcached这类key/value存储的不足，

提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。

优点：

1 Redis读写性能优异，从内存当中进行IO读写速度快，支持超过100K+每秒的读写频率。

2 Redis支持Strings,

Lists, Hashes, Sets,Ordered Sets等数据类型操作。

3 Redis支持数据持久化，支持AOF和RDB两种持久化方式

4 Redis支持主从复制，主机会自动将数据同步到从机，可以进行读写分离。

5 Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。

6 Redis是单线程多CPU，不需要考虑加锁释放锁，也就没有死锁的问题，效率高。

1：redis队列值入队出队,截图效果：

优化之前入队1000条数据，测试结果将近50秒，这实在太慢，不可忍受！

 优化后的效果：为5.55s的样子

 

2：redis发布与订阅截图效果：(一个发布者，四个订阅者) 订阅者都会收到相同的信息

 3：redis秒杀，截图如下：单个进程秒杀ok

开多个进程时，会有超卖的现象：（那我加lock锁呢？结果也是会有超卖的现象，此时下面的分布式锁可以解决）

 4：加上redis分布式锁的测试效果截图：

但是这样会比较耗资源，库存已经没有了，就应该不要再去执行下去了

分布式锁ok库存为零就不在请求直接抛异常即可

 上面通过测试的截图，简单的介绍了，Redis的队列(入队和出队)，Redis发布与订阅，Redis分布式锁的使用，现在直接上代码 ：

出队入队的WebApi Core3.1

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;


namespace WebApp.Controllers
{
    using Microsoft.AspNetCore.Mvc;
    using RedisPublishAndSubHelper;
    [Route("api/[Controller]")]
    [ApiController]
    public class RedisTestController
    {
        [HttpGet("EnqueueMsg")]
        public async Task<ApiResultObject> EnqueueMsgAsync(string rediskey, string redisValue)
        {
            ApiResultObject obj = new ApiResultObject();
            try
            {
                long enqueueLong = default;
                for (int i = 0; i < 1000; i++)
                {
                    enqueueLong = await MyRedisSubPublishHelper.EnqueueListLeftPushAsync(rediskey, redisValue + i);
                }
                obj.Code = ResultCode.Success;
                obj.Data = "入队的数据长度：" + enqueueLong;
                obj.Msg = "入队成功！";
            }
            catch (Exception ex)
            {


                obj.Msg = $"入队异常，原因：{ex.Message}";
            }
            return obj;
        }
        [HttpGet("DequeueMsg")]
        public async Task<ApiResultObject> DequeueMsgAsync(string rediskey)
        {
            ApiResultObject obj = new ApiResultObject();
            try
            {
                string dequeueMsg = await MyRedisSubPublishHelper.DequeueListPopRightAsync(rediskey);
                obj.Code = ResultCode.Success;
                obj.Data = $"出队的数据是：{dequeueMsg}";
                obj.Msg = "入队成功！";
            }
            catch (Exception ex)
            {
                obj.Msg = $"入队异常，原因：{ex.Message}";
            }
            return obj;
        }
    }
}

出队入队的后端code WebApi：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;


namespace WebApp.Controllers
{
    using Microsoft.AspNetCore.Mvc;
    using RedisPublishAndSubHelper;
    [Route("api/[Controller]")]
    [ApiController]
    public class RedisTestController
    {
        [HttpGet("EnqueueMsg")]
        public async Task<ApiResultObject> EnqueueMsgAsync(string rediskey, string redisValue)
        {
            ApiResultObject obj = new ApiResultObject();
            try
            {
                long enqueueLong = default;
                for (int i = 0; i < 1000; i++)
                {
                    enqueueLong = await MyRedisSubPublishHelper.EnqueueListLeftPushAsync(rediskey, redisValue + i);
                }
                obj.Code = ResultCode.Success;
                obj.Data = "入队的数据长度：" + enqueueLong;
                obj.Msg = "入队成功！";
            }
            catch (Exception ex)
            {


                obj.Msg = $"入队异常，原因：{ex.Message}";
            }
            return obj;
        }
        [HttpGet("DequeueMsg")]
        public async Task<ApiResultObject> DequeueMsgAsync(string rediskey)
        {
            ApiResultObject obj = new ApiResultObject();
            try
            {
                string dequeueMsg = await MyRedisSubPublishHelper.DequeueListPopRightAsync(rediskey);
                obj.Code = ResultCode.Success;
                obj.Data = $"出队的数据是：{dequeueMsg}";
                obj.Msg = "入队成功！";
            }
            catch (Exception ex)
            {
                obj.Msg = $"入队异常，原因：{ex.Message}";
            }
            return obj;
        }
    }
}

入队以及秒杀分布式锁的客服端的Code：

 

using System;
using System.Threading;
using System.Threading.Tasks;


namespace RedisPublishService
{
    using RedisPublishAndSubHelper;
    class Program
    {
        static void Main(string[] args)
        {
            #region 入队的code
            {
                int Index = 100000;
                while (Index > 0)
                {
                    //string msg = Console.ReadLine();
                    new MyRedisSubPublishHelper().PublishMessage("nihaofengge", $"你好风哥：Guid值是：{DateTime.Now}{Guid.NewGuid().ToString()}");
                    Console.WriteLine("发布成功！");
                    Index -= 1;
                }
                Console.ReadKey();
            }
            #endregion


            #region 秒杀的code
            {
                try
                {
                    Console.WriteLine("秒杀开始。。。。。");
                    for (int i = 0; i < 200; i++)
                    {
                        Task.Run(() =>
                        {
                            MyRedisSubPublishHelper.LockByRedis("mstest");
                            string productCount = MyRedisHelper.StringGet("productcount");
                            int pcount = int.Parse(productCount);
                            if (pcount > 0)
                            {
                                long dlong = MyRedisHelper.StringDec("productcount");
                                Console.WriteLine($"秒杀成功，商品库存:{dlong}");
                                pcount -= 1;
                                System.Threading.Thread.Sleep(30);
                            }
                            else
                            {
                                Console.WriteLine($"秒杀失败，商品库存为零了！");
                                throw new Exception("产品秒杀数量为零！");//加载这里会比较保险
                        }
                            MyRedisSubPublishHelper.UnLockByRedis("mstest");
                        }).Wait();
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"产品已经秒杀完毕，原因：{ex.Message}");
                }
                Console.ReadKey();
            }
            #endregion
        }
    }
}

完整的code RedisHelper帮助类(测试并使用了部分方法的封装)，

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;


namespace RedisPublishAndSubHelper
{
    using StackExchange.Redis;
    using StackExchange;
    using System.Threading;


    public class MyRedisHelper
    {
        private static readonly string connectionRedisStr = string.Empty;
        static MyRedisHelper()
        {
            //在这里来初始化一些配置信息
            connectionRedisStr = "12.23.45.12:6379,connectTimeout=1000,connectRetry=3,syncTimeout=10000";
        }


        #region Redis string简单的常见同步方法操作
        public static bool StringSet(string key, string stringValue, double senconds = 60)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                IDatabase db = conn.GetDatabase();
                return db.StringSet(key, stringValue, TimeSpan.FromSeconds(senconds));
            }
        }
        public static string StringGet(string key)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                IDatabase db = conn.GetDatabase();
                return db.StringGet(key);
            }
        }


        public static long StringInc(string key)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                IDatabase db = conn.GetDatabase();
                return db.StringIncrement(key);
            }
        }


        public static long StringDec(string key)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                IDatabase db = conn.GetDatabase();
                return db.StringDecrement(key);
            }
        }
        public static bool KeyExists(string key)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                IDatabase db = conn.GetDatabase();
                return db.KeyExists(key);
            }
        }
        #endregion


        #region List Hash, Set,Zset 大同小异的使用，比较简单,后续有时间再补上


        #endregion


        #region 入队出队


        #region 入队
        /// <summary>
        /// 入队right
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="redisValue"></param>
        /// <returns></returns>
        public static long EnqueueListRightPush(RedisKey queueName, RedisValue redisValue)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                return conn.GetDatabase().ListRightPush(queueName, redisValue);
            }
        }
        /// <summary>
        /// 入队left
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="redisvalue"></param>
        /// <returns></returns>
        public static long EnqueueListLeftPush(RedisKey queueName, RedisValue redisvalue)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                return conn.GetDatabase().ListLeftPush(queueName, redisvalue);
            }
        }
        /// <summary>
        /// 入队left异步
        /// </summary>
        /// <param name="queueName"></param>
        /// <param name="redisvalue"></param>
        /// <returns></returns>
        public static async Task<long> EnqueueListLeftPushAsync(RedisKey queueName, RedisValue redisvalue)
        {
            using (var conn = await ConnectionMultiplexer.ConnectAsync(connectionRedisStr))
            {
                return await conn.GetDatabase().ListLeftPushAsync(queueName, redisvalue);
            }
        }
        /// <summary>
        /// 获取队列的长度
        /// </summary>
        /// <param name="queueName"></param>
        /// <returns></returns>
        public static long EnqueueListLength(RedisKey queueName)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                return conn.GetDatabase().ListLength(queueName);
            }
        }


        #endregion


        #region 出队
        public static string DequeueListPopLeft(RedisKey queueName)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                IDatabase database = conn.GetDatabase();
                int count = database.ListRange(queueName).Length;
                if (count <= 0)
                {
                    throw new Exception($"队列{queueName}数据为零");
                }
                string redisValue = database.ListLeftPop(queueName);
                if (!string.IsNullOrEmpty(redisValue))
                    return redisValue;
                else
                    return string.Empty;
            }
        }
        public static string DequeueListPopRight(RedisKey queueName)
        {
            using (var conn = ConnectionMultiplexer.Connect(connectionRedisStr))
            {
                IDatabase database = conn.GetDatabase();
                int count = database.ListRange(queueName).Length;
                if (count <= 0)
                {
                    throw new Exception($"队列{queueName}数据为零");
                }
                string redisValue = conn.GetDatabase().ListRightPop(queueName);
                if (!string.IsNullOrEmpty(redisValue))
                    return redisValue;
                else
                    return string.Empty;
            }
        }
        public static async Task<string> DequeueListPopRightAsync(RedisKey queueName)
        {
            using (var conn = await ConnectionMultiplexer.ConnectAsync(connectionRedisStr))
            {
                IDatabase database = conn.GetDatabase();
                int count = (await database.ListRangeAsync(queueName)).Length;
                if (count <= 0)
                {
                    throw new Exception($"队列{queueName}数据为零");
                }
                string redisValue = await conn.GetDatabase().ListRightPopAsync(queueName);
                if (!string.IsNullOrEmpty(redisValue))
                    return redisValue;
                else
                    return string.Empty;
            }
        }
        #endregion


        #endregion


        #region 分布式锁
        public static void LockByRedis(string key, int expireTimeSeconds = 10)
        {
            try
            {
                IDatabase database1 = ConnectionMultiplexer.Connect(connectionRedisStr).GetDatabase();
                while (true)
                {
                    expireTimeSeconds = expireTimeSeconds > 20 ? 10 : expireTimeSeconds;
                    bool lockflag = database1.LockTake(key, Thread.CurrentThread.ManagedThreadId, TimeSpan.FromSeconds(expireTimeSeconds));
                    if (lockflag)
                    {
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"Redis加锁异常:原因{ex.Message}");
            }
        }


        public static bool UnLockByRedis(string key)
        {
            ConnectionMultiplexer conn = ConnectionMultiplexer.Connect(connectionRedisStr);
            try
            {
                IDatabase database1 = conn.GetDatabase();
                return database1.LockRelease(key, Thread.CurrentThread.ManagedThreadId);
            }
            catch (Exception ex)
            {
                throw new Exception($"Redis加锁异常:原因{ex.Message}");
            }
            finally
            {
                if (conn != null)
                {
                    conn.Close();
                    conn.Dispose();
                }
            }
        }
        #endregion


    }
}

 

using System;
using System.Collections.Generic;
using System.Text;


namespace RedisPublishAndSubHelper
{
    using StackExchange.Redis;
    using System.Net.Http;
    using System.Threading;
    using System.Threading.Channels;
    using System.Threading.Tasks;


    public class MyRedisSubPublishHelper
    {
        private static readonly string redisConnectionStr = "12.32.12.54:6379,connectTimeout=10000,connectRetry=3,syncTimeout=10000";
        private static readonly ConnectionMultiplexer connectionMultiplexer = null;
        static MyRedisSubPublishHelper()
        {
            connectionMultiplexer = ConnectionMultiplexer.Connect(redisConnectionStr);
        }




        #region 发布订阅
        public void SubScriper(string topticName, Action<RedisChannel, RedisValue> handler = null)
        {
            ISubscriber subscriber = connectionMultiplexer.GetSubscriber();
            ChannelMessageQueue channelMessageQueue = subscriber.Subscribe(topticName);
            channelMessageQueue.OnMessage(channelMessage =>
            {
                if (handler != null)
                {
                    string redisChannel = channelMessage.Channel;
                    string msg = channelMessage.Message;
                    handler.Invoke(redisChannel, msg);
                }
                else
                {
                    string msg = channelMessage.Message;
                    Console.WriteLine($"订阅到消息: { msg},Channel={channelMessage.Channel}");
                }
            });
        }
        public void PublishMessage(string topticName, string message)
        {
            ISubscriber subscriber = connectionMultiplexer.GetSubscriber();
            long publishLong = subscriber.Publish(topticName, message);
            Console.WriteLine($"发布消息成功：{publishLong}");
        }
        #endregion


        #region 入队出队
        public static async Task<long> EnqueueListLeftPushAsync(RedisKey queueName, RedisValue redisvalue)
        {
            return await connectionMultiplexer.GetDatabase().ListLeftPushAsync(queueName, redisvalue);
        }


        public static async Task<string> DequeueListPopRightAsync(RedisKey queueName)
        {
            IDatabase database = connectionMultiplexer.GetDatabase();
            int count = (await database.ListRangeAsync(queueName)).Length;
            if (count <= 0)
            {
                throw new Exception($"队列{queueName}数据为零");
            }
            string redisValue = await database.ListRightPopAsync(queueName);
            if (!string.IsNullOrEmpty(redisValue))
                return redisValue;
            else
                return string.Empty;
        }
        #endregion


        #region 分布式锁
        public static void LockByRedis(string key, int expireTimeSeconds = 10)
        {
            try
            {
                IDatabase database = connectionMultiplexer.GetDatabase();
                while (true)
                {
                    expireTimeSeconds = expireTimeSeconds > 20 ? 10 : expireTimeSeconds;
                    bool lockflag = database.LockTake(key, Thread.CurrentThread.ManagedThreadId, TimeSpan.FromSeconds(expireTimeSeconds));
                    if (lockflag)
                    {
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"Redis加锁异常:原因{ex.Message}");
            }
        }


        public static bool UnLockByRedis(string key)
        {
            try
            {
                IDatabase database = connectionMultiplexer.GetDatabase();
                return database.LockRelease(key, Thread.CurrentThread.ManagedThreadId);
            }
            catch (Exception ex)
            {
                throw new Exception($"Redis加锁异常:原因{ex.Message}");
            }
        }
        #endregion
    }
}
dotNET知音
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis 发布订阅实际案例_.NetCore使用Redis，StackExchange.Redis队列，发布与订阅，分布式锁的简单使用...
weixin_39530839的博客
11-29 569
https://www.cnblogs.com/Fengge518/p/13556182.html环境：之前一直是使用serverStack.Redis的客服端，今天来使用一下StackExchange.Redis(个人感觉更加的人性化一些，也是免费的，性能也不会差太多)，版本为StackExchange.Redis V2.1.58 ,Core3.1简单的说明(专业的术语参考资料网络和官...
.net core使用redis基于StackExchange.Redis
10-19
主要为大家详细介绍了.net core使用redis基于StackExchange.Redis的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
StackExchange.Redis学习笔记(五) 发布和订阅
weixin_30512089的博客
01-30 215
StackExchange.Redis学习笔记(五) 发布和订阅 原文:StackExchange.Redis学习笔记(五) 发布和订阅 Redis命令中的Pub/Sub Redis在 2.0之后的版本中 实现了 事件推送的 发布订阅命令 以下是Redis关于发布和订阅提供的相关命令 SUBSCRIBE channel [cha...
C# StackExchange.Redis 操作封装类库
05-20
【实例简介】 C# StackExchange.Redis 操作封装类库，分别封装了Redis五大数据结构（String，Hash，List，Set，ZSet）的增删改查的操作方法，支持Async异步操作。​支持Redis分库操作。支持信息队列操作。 带有单元测试，为每个方法都做了测试。包括Redis队列操作测试
StackExchange.Redis跑起来，为什么这么溜？
最新发布
jjc4261的博客
05-29 868
通过对同步API、异步API的执行逻辑分析，我这里总结了一张图，可以让大家快速的理清其中的处理逻辑。我再用文字描述下这个执行逻辑：1、无论是同步调用还是异步调用，StackExchange.Redis 底层都是先会创建一个 Message 对象；每个 Message 对象都会关联一个ResultBox对象（同步和异步调用对应的ResultBox对象略有不同），这个对象用来承载Redis执行结果；
C# StackExchange.Redis 用法总结
长春小佛爷的博客
02-24 3692
1、安装 StackExchange.Redis 在 NuGet 中搜索 StackExchange.Redis 和 Newtonsoft.Json，直接点击按钮安装即可。 StackExchange.Redis 是 C# 操作 Redis 数据库的客户端。 Newtonsoft.Json 用来序列化 Josn 字符串及反序列化拿到对象。 2、引用及初始化 引用 using StackExchange.Redis; using Newtonsoft.Json; 初始化 redis C..
Redis---StackExchange 学习笔记
weixin_30244889的博客
04-06 138
周末，花了一天多时间，学习了内存数据库redis。虽然网上有很多教程，但是，由于该项目，需要用到的dll很多，导致初学者不能正常编译运行。 redisC#开源架构有ServiceStackStackExchange csRedis。ServiceStack 要收费，而且新老版本改动较大，很多接口不能用。csRedis是国人开发的，文献很少，万一遇到坑，自己填！ 所以，...
StackExchange.Redis的基本使用
飞翔的学习笔记
03-17 1万+
StackExchange.Redis是一款免费的操作Redis的客户端工具，我们使用这个库来简单的学习下Redis的一些基本操作 Redis默认安装好后的端口是6379 密码可以自己设置，使用命令修改 config get requirepass //获取当前密码 config set requirepass "yourpassword"//设置当前密码 代码里需引用StackExch...
.NetCore基于SignalR、Reids实现客服WebIM系统
用心,承载未来
09-19 848
WebIM客服系统，说明当前系统与自己的业务系统关联性不强。基于这个前提，最终把WebIM完善成了一个易接入、高度开放、不依赖于业务系统、支持接入多个业务系统的售后服务系统
CachingFramework.Redis:基于StackExchange.Redis和Redis的分布式缓存。 包括对标记的支持并且与群集兼容
04-29
缓存框架 基于.NET Redis客户端库添加了一些有趣的功能，例如可扩展的序列化策略，用于对键，哈希字段和set成员进行分组的标记机制以及用于支持原子添加/获取操作的获取机制，所有... Redis键空间通知：订阅发布/订
.net core如何使用Redis发布订阅
10-19
本篇文章主要介绍了.net core如何使用Redis发布订阅，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解Asp.net Core 使用Redis存储Session
10-20
这里我们使用`RedisCache`类，它继承自`IDistributedCache`并利用`StackExchange.Redis`库与Redis服务器通信。在`RedisCache`类中，关键的方法包括`Get`, `Set`, `Remove`等，用于存取和删除Session数据。 ```...
【ASP.NET编程知识】详解如何在ASP.NET Core中使用Redis.docx
05-21
【ASP.NET Core中使用Redis详解】 在ASP.NET Core应用程序中集成Redis可以提升应用程序的性能，因为Redis作为一个内存数据存储系统，提供了快速的数据访问。本文将详细介绍如何在ASP.NET Core环境中配置和使用Redis...
StackOverflow和StackExchange的关系
DeerBigRed的博客
04-08 5122
创始人乔尔•斯伯斯基（Joel Spolsky） 　　以下为专访摘录： 　　问：请简单介绍下StackExchange和Stack Overflow。 　　答：我们最早设立的是Stack Overflow，即一个供程序员互相解答编程问题的问答网站，随后我们试图将同样的技术推广到编程之外的领域，比如说烹饪、摄影等等，每个主题的问答站点就都称为StackExchange，合起来也就是StackE...
第12章 初识消息队列(MessageQueuing)
zhoujian_911的专栏
12-08 1011
通过Redis分布式缓存数据库或RabbitMQ实现消息队列(MessageQueuing)
.NetCore SignalR 3.1 简单应用
weixin_43965881的博客
03-18 3212
.NetCore SignalR 3.1 简单应用SignalR服务端与客户端的调用案列介绍一.创建项目、配置环境二.创建一个SignalR中心三.服务端进行推送四.如何在Startup配置中配置SignalR五.客户端效果展示 SignalR服务端与客户端的调用案列 介绍 ASP.NET Core SignalR 是一个开源代码库，它简化了向应用添加实时 Web 功能的过程。 实时 Web 功能...
.NetCore 使用StackExchange.Redis 连接Redis
热门推荐
Stay Hungry
07-21 1万+
StackExchange.Redis是一个.Net平台上使用较为广泛的一个Redis封装 1.安装Redis 前提是得先在本机上安装Redis，由于我是在window上,访问以下链接下载windows安装包 https://github.com/microsoftarchive/redis/releases 若是安装在linux中，则直接访问redis.io ，redis官网上...
C#操作redis（StackExchange.Redis）
Ancolie的博客
10-24 1万+
C#操作redis 入门步骤： 安装redis–安装可视化软件RedisDesktopManager–C#操作redis 前两步软件的安装教程很多，这里不赘述。 一、类库的选择 在C#中使用Redis，一般有两种方式： 1、ServiceStack.Redis，据说是Redis官方推荐使用的驱动类库，但是是收费的。 2、StackExchange.Redis，可能性能要比ServiceStack.Redis差点，但是是免费的。 经过多方调研，我选用StackExchange.Redis来实现Redis操作，
C# 使用stackexchange.redis操作redis
weixin_47135180的博客
04-17 1034
我们使用stackexchange.redis,主要原因是它开源免费。
ASP.NET编程知识：使用.NetCore演示RabbitMQ死信队列和延时队列
使用.NetCore实例讲解RabbitMQ死信队列和延时队列 本文将以.NetCore为例，详细讲解RabbitMQ死信队列和延时队列的使用方法。文中包括了死信队列和延时队列的概念介绍，还有不同过期时间的延时消息设置，以及如何用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值