c# 使用Memory实现Redis入队出队功能

原创 已于 2025-11-05 13:28:11 修改 · 99 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c# #redis

于 2025-11-05 11:11:55 首次发布

使用net6.0的memory实现Redis的入队出队功能

nuget包：

Microsoft.Extensions.Caching.Memory
Microsoft.Extensions.Configuration
Microsoft.Extensions.DependencyInjection

using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using System.Collections.Concurrent;
    
    public interface IMemoryCacheListService
    {
        /// <summary>
        /// 在列表的尾部（右侧）添加一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        Task<long> RPushAsync<T>(string key, T value, TimeSpan? expiry = null);

        /// <summary>
        /// 在列表的头部（左侧）添加一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        Task<long> LPushAsync<T>(string key, T value, TimeSpan? expiry = null);

        /// <summary>
        /// 移除并返回列表头部（左侧）的第一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<T> LPopAsync<T>(string key);

        /// <summary>
        /// 移除并返回列表尾部（右侧）的最后一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<T> RPopAsync<T>(string key);

        /// <summary>
        /// 返回列表中指定范围内的元素。范围由起始索引（start）和结束索引（stop）指定，支持负数索引（表示从尾部开始计算）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        Task<List<T>> LRangeAsync<T>(string key, int start, int stop);

        /// <summary>
        /// 返回列表的长度
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<long> LLenAsync<T>(string key);

        /// <summary>
        /// 通过索引获取列表中的元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        Task<T> LIndexAsync<T>(string key, int index);

        /// <summary>
        /// 为列表设置过期时间
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        Task<bool> ExpireAsync<T>(string key, TimeSpan expiry);

        /// <summary>
        /// 修剪列表，只保留指定范围内的元素，其他元素将被删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        Task<bool> LTrimAsync<T>(string key, int start, int stop);

        /// <summary>
        /// 移除列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<bool> RemoveAsync<T>(string key);

        /// <summary>
        /// 获取列表中的所有元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        IAsyncEnumerable<T> GetItemsAsync<T>(string key);
    }

    public class MemoryCacheListService : IMemoryCacheListService, IDisposable
    {
        private readonly IMemoryCache _memoryCache;
        private readonly IOptions<CustomMemoryCacheOptions> _options;
        private readonly ConcurrentDictionary<string, SemaphoreSlim> _semaphores = new();

        public MemoryCacheListService(
            IMemoryCache memoryCache,
            IOptions<CustomMemoryCacheOptions> options = null)
        {
            _memoryCache = memoryCache;
            _options = options;
        }

        /// <summary>
        /// 在列表的尾部（右侧）添加一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public async Task<long> RPushAsync<T>(string key, T value, TimeSpan? expiry = null)
        {
            var cacheKey = GetCacheKey(key);
            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));

            await semaphore.WaitAsync();

            try
            {
                if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null)
                {
                    list = new List<T>();
                }

                list.Add(value);
                SetListWithExpiry(cacheKey, list, expiry);
                return list.Count;
            }
            finally
            {
                semaphore.Release();
            }
        }

        /// <summary>
        /// 在列表的头部（左侧）添加一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public async Task<long> LPushAsync<T>(string key, T value, TimeSpan? expiry = null)
        {
            var cacheKey = GetCacheKey(key);
            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));

            await semaphore.WaitAsync();

            try
            {
                if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null)
                {
                    list = new List<T>();
                }

                list.Insert(0, value);
                SetListWithExpiry(cacheKey, list, expiry);
                return list.Count;
            }
            finally
            {
                semaphore.Release();
            }
        }

        /// <summary>
        /// 移除并返回列表头部（左侧）的第一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> LPopAsync<T>(string key)
        {
            var cacheKey = GetCacheKey(key);
            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));

            await semaphore.WaitAsync();

            try
            {
                if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null || list.Count == 0)
                {
                    return default(T);
                }

                var value = list[0];
                list.RemoveAt(0);
                if (list.Count > 0)
                {
                    SetListWithExpiry(cacheKey, list);
                }
                else
                {
                    _memoryCache.Remove(cacheKey);
                }

                return value;
            }
            finally
            {
                semaphore.Release();
            }
        }

        /// <summary>
        /// 移除并返回列表尾部（右侧）的最后一个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<T> RPopAsync<T>(string key)
        {
            var cacheKey = GetCacheKey(key);
            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));

            await semaphore.WaitAsync();

            try
            {
                if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null || list.Count == 0)
                {
                    return default(T);
                }

                // 修复：正确获取最后一个元素
                var value = list[list.Count - 1]; // 正确的索引访问
                list.RemoveAt(list.Count - 1);
                if (list.Count > 0)
                {
                    SetListWithExpiry(cacheKey, list);
                }
                else
                {
                    _memoryCache.Remove(cacheKey);
                }
                return value;
            }
            finally
            {
                semaphore.Release();
            }
        }

        /// <summary>
        /// 返回列表中指定范围内的元素。范围由起始索引（start）和结束索引（stop）指定，支持负数索引（表示从尾部开始计算）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        public async Task<List<T>> LRangeAsync<T>(string key, int start, int stop)
        {
            var cacheKey = GetCacheKey(key);

            if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null)
            {
                return new List<T>();
            }

            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));
            await semaphore.WaitAsync();

            try
            {
                var normalizedStart = NormalizeIndex(start, list.Count);
                var normalizedStop = NormalizeIndex(stop, list.Count);

                normalizedStart = Math.Max(0, normalizedStart);
                normalizedStop = Math.Min(list.Count - 1, normalizedStop);

                if (normalizedStart > normalizedStop)
                    return new List<T>();

                return list.GetRange(normalizedStart, normalizedStop - normalizedStart + 1);
            }
            finally
            {
                semaphore.Release();
            }
        }

        /// <summary>
        /// 返回列表的长度
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<long> LLenAsync<T>(string key)
        {
            var cacheKey = GetCacheKey(key);

            if (_memoryCache.TryGetValue(cacheKey, out List<T> list) && list != null)
            {
                return list.Count;
            }

            return 0;
        }

        /// <summary>
        /// 通过索引获取列表中的元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public async Task<T> LIndexAsync<T>(string key, int index)
        {
            var cacheKey = GetCacheKey(key);

            if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null || list.Count == 0)
            {
                return default(T);
            }

            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));
            await semaphore.WaitAsync();

            try
            {
                var normalizedIndex = NormalizeIndex(index, list.Count);
                if (normalizedIndex < 0 || normalizedIndex >= list.Count)
                    return default(T);

                return list[normalizedIndex];
            }
            finally
            {
                semaphore.Release();
            }
        }

        /// <summary>
        /// 为列表设置过期时间
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public async Task<bool> ExpireAsync<T>(string key, TimeSpan expiry)
        {
            var cacheKey = GetCacheKey(key);
            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));

            await semaphore.WaitAsync();

            try
            {
                if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null)
                {
                    return false;
                }

                SetListWithExpiry(cacheKey, list, expiry);
                return true;
            }
            finally
            {
                semaphore.Release();
            }
        }

        /// <summary>
        /// 修剪列表，只保留指定范围内的元素，其他元素将被删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        public async Task<bool> LTrimAsync<T>(string key, int start, int stop)
        {
            var cacheKey = GetCacheKey(key);
            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));

            await semaphore.WaitAsync();

            try
            {
                if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null)
                {
                    return false;
                }

                var normalizedStart = NormalizeIndex(start, list.Count);
                var normalizedStop = NormalizeIndex(stop, list.Count);

                normalizedStart = Math.Max(0, normalizedStart);
                normalizedStop = Math.Min(list.Count - 1, normalizedStop);

                if (normalizedStart > normalizedStop)
                {
                    list.Clear();
                }
                else
                {
                    var newList = list.GetRange(normalizedStart, normalizedStop - normalizedStart + 1);
                    list.Clear();
                    list.AddRange(newList);
                }

                if (list.Count > 0)
                {
                    SetListWithExpiry(cacheKey, list);
                }
                else
                {
                    _memoryCache.Remove(cacheKey);
                }

                return true;
            }
            finally
            {
                semaphore.Release();
            }
        }

        /// <summary>
        /// 移除列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<bool> RemoveAsync<T>(string key)
        {
            var cacheKey = GetCacheKey(key);
            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));

            await semaphore.WaitAsync();

            try
            {
                _memoryCache.Remove(cacheKey);
                return true;
            }
            finally
            {
                semaphore.Release();
                _semaphores.TryRemove(cacheKey, out _);
            }
        }

        /// <summary>
        /// 获取列表中的所有元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async IAsyncEnumerable<T> GetItemsAsync<T>(string key)
        {
            var cacheKey = GetCacheKey(key);

            if (!_memoryCache.TryGetValue(cacheKey, out List<T> list) || list == null)
            {
                yield break;
            }

            var semaphore = _semaphores.GetOrAdd(cacheKey, _ => new SemaphoreSlim(1, 1));
            await semaphore.WaitAsync();

            try
            {
                foreach (var item in list)
                {
                    yield return item;
                }
            }
            finally
            {
                semaphore.Release();
            }
        }

        private string GetCacheKey(string key) => $"list_{key}";

        private void SetListWithExpiry<T>(string cacheKey, List<T> list, TimeSpan? expiry = null)
        {
            var cacheOptions = new MemoryCacheEntryOptions();

            if (expiry.HasValue)
            {
                cacheOptions.AbsoluteExpirationRelativeToNow = expiry;
            }
            else
            {
                cacheOptions.SlidingExpiration = _options?.Value.DefaultSlidingExpiration;
                cacheOptions.AbsoluteExpirationRelativeToNow = _options?.Value.DefaultAbsoluteExpiration;
            }

            _memoryCache.Set(cacheKey, list, cacheOptions);
        }

        private int NormalizeIndex(int index, int count)
        {
            return index < 0 ? count + index : index;
        }

        public void Dispose()
        {
            foreach (var semaphore in _semaphores.Values)
            {
                semaphore.Dispose();
            }
            _semaphores.Clear();
        }
    }

    public class CustomMemoryCacheOptions
    {
        /// <summary>
        /// 相对过期时间（滑动过期时间）
        /// </summary>
        public TimeSpan? DefaultSlidingExpiration { get; set; } = TimeSpan.FromMinutes(30);

        /// <summary>
        /// 绝对过期时间
        /// </summary>
        public TimeSpan? DefaultAbsoluteExpiration { get; set; } = TimeSpan.FromHours(1);
    }

Sample：

var key = "key";

var services = new ServiceCollection();// 创建ServiceCollection
// 注册缓存服务
services.Configure<CustomMemoryCacheOptions>(options =>
{
    options.DefaultSlidingExpiration = TimeSpan.FromMinutes(30);
    options.DefaultAbsoluteExpiration = TimeSpan.FromHours(2);
});
services.AddTransient<IMemoryCacheListService, MemoryCacheListService>();
services.AddMemoryCache();
var serviceProvider = services.BuildServiceProvider();


var stackService = serviceProvider.GetRequiredService<IMemoryCacheListService>();

#region Queue 先进先出

Console.WriteLine($"Queue 先进先出");

await stackService.RPushAsync(key, "item1");
await stackService.RPushAsync(key, "item2");
await stackService.RPushAsync(key, "item3");

while (true)
{
    string value = await stackService.LPopAsync<string>(key);
    if (value == null)
        break;
    Console.WriteLine($"Time:{DateTime.Now:yyyy-MM-dd HH:mm:ss} Message: {value}");
    await Task.Delay(1000);
}

#endregion

#region Stack 先进后出

Console.WriteLine($"Stack 先进后出");

await stackService.RPushAsync(key, "item1");
await stackService.RPushAsync(key, "item2");
await stackService.RPushAsync(key, "item3");

while (true)
{
    string value = await stackService.RPopAsync<string>(key);
    if (value == null)
        break;
    Console.WriteLine($"Time:{DateTime.Now:yyyy-MM-dd HH:mm:ss} Message: {value}");
    await Task.Delay(1000);
}

#endregion

Console.ReadKey();

output：

C#分布式任务队列的“量子加速”秘籍：从卡顿到飞起的N个技巧！
java专栏
04-28 532
🔥关注墨瑾轩，带你探索编程的奥秘！🚀🔥超萌技术攻略，轻松晋级编程高手🚀🔥技术宝库已备好，就等你来挖掘🚀🔥订阅墨瑾轩，智趣学习不孤单🚀🔥即刻启航，编程之旅更有趣🚀taskIdtaskId。
Redis基础知识四
m0_74120645的博客
05-27 1388
大 key 并不是指 key 的值很大，而是 key 对应的 value 很大。一般而言，下面这两种情况被称为大 key：String 类型的值大于 10 KB；Hash、List、Set、ZSet 类型的元素的个数超过 5000个；
中间件 - redis
十月初七
02-20 2280
redis各个类型的基本使用原理以及如何整合到springboot项目中使用
Redis详解
一条没有梦想的闲鱼的博客
01-24 3281
一、Redis概述 1. Redis是什么 Redis（Remote Dictionary Server）,远程字典服务。是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。 Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。 2.Redis可以干什么 1.内存存储，持久化，内存中断点即失，所以说持久化很重要。持久化的方式：RDB...
Redis 7.0 核心技术、实战应用、面试题
weixin_46812727的博客
03-04 2893
Redis 7 核心技术与实战应用 面试题
Redis基础安装使用到集群
♾️
01-12 2880
第一节 Redis简介 1.1 NoSQL NoSQL，泛指非关系型的数据库，NoSQL即Not-Only SQL，它可以作为关系型数据库的良好补充。随着互联网web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关系数据库产品的发展非常迅速 而传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服...
Redis相关问题及答案
qq_43012298的博客
12-16 1418
选择哪种集群方式取决于具体的应用需求，包括需要支持的数据量大小、读写操作的比例、可用性和一致性的要求等。对于需要自动数据分片和高可用性的情况，官方的 Redis 集群模式通常是首选。而如果对稳定性和简单性的要求更高，可能会选择哨兵模式，尤其是当不需要水平扩展写操作能力时。主从复制模式适用于数据冗余和读扩展。在实际部署时，这些模式有时会根据需求进行混合以达到最优的架构设计。9、Redis的键有哪些过期策略？
Redis学习笔记2
学习技术的路上不断沉淀自己
03-20 3245
个人博客 欢迎访问个人博客: https://www.crystalblog.xyz/ 备用地址: https://wang-qz.gitee.io/crystal-blog/ 1. Redis入门 1.1 Redis简介 B站视频: https://www.bilibili.com/video/BV1CJ411m7Gc?spm_id_from=333.1007.top_right_bar_window_custom_collection.content.click 1.1.1 Redis引入 2007年1
Redis
qq_44394907的博客
04-01 180
Redis 版本： redis 3.2.11 第一节 Redis简介 1.1 NoSQL NoSQL，泛指非关系型的数据库，NoSQL即Not-Only SQL，它可以作为关系型数据库的良好补充。随着互联网web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关系数据库产品的发展非常迅速 而传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，例如： 1、High performance - 对数
java面试题 -redis 2024最新版（四）
qq_15363475的博客
06-17 884
Redis是单线程的主要原因在于其高效的设计和对性能的极致追求。内存操作的高效性：Redis的所有数据都存储在内存中，这使得数据的读写速度非常快。由于内存操作的效率远高于磁盘操作，因此单线程足以处理大量的读写请求，而不会成为性能瓶颈。简化设计和实现：单线程模型简化了Redis的设计和实现。它避免了多线程编程中的竞态条件、锁的管理和上下文切换等复杂问题，降低了开发和维护的难度。避免上下文切换开销：在多线程模型中，线程之间的上下文切换会引入额外的开销。
Redis实战（通俗易懂，超详细攻略） V2.0版本
热门推荐
B君的军火库
04-28 1万+
Redis内存数据库
Redis键值对NoSQL数据库基础入门
java编程学习_java基础教程_booyzhang的博客
07-15 801
一、引言 1、数据库压力过大 由于用户量增大，请求数量也随之增大，数据压力过大 2、数据不同步 多台服务器之间，数据不同步 3、传统锁失效 多台服务器之间的锁，已经不存在互斥性了。 二、Redis介绍 1、NoSQL NoSQL，泛指非关系型的数据库，NoSQL即Not-Only SQL，它可以作为关系型数据库的良好补充。随着互联网web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关系数据库产品的发展非常迅速 而传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型
C#并发集合性能分析：使用与优化技巧
它们通过减少锁的使用或消除锁，允许不同的线程或任务安全地同时访问和修改数据，而不会相互干扰。这使得开发人员能够更加专注于业务逻辑的实现，而不是花大量时间处理线程同步问题。 简而言之，理解并发集合在C#中...
C#.NET SemaphoreSlim 深入解析：轻量级异步锁与并发控制
tangPHP的博客
11-05 624
摘要： SemaphoreSlim 是 .NET 中轻量级的同步原语，用于控制共享资源的并发访问，相比传统 Semaphore 性能更高，支持异步操作（WaitAsync）。它适用于限制并发线程数（如数据库连接池、API 限流），提供超时、取消和批量释放功能。核心 API 包括 Wait/WaitAsync（获取信号量）、Release（释放资源）和 CurrentCount（查看当前可用数）。典型场景包括异步任务调度和资源池管理，能有效避免竞争条件，适合现代 .NET 应用的高并发需求。
现代 C# WebAPI 中的 API 版本控制最佳实践
m0_74000869的博客
11-05 248
本文介绍了在C# WebAPI中实现多版本控制的方法。首先通过安装Microsoft.AspNetCore.Mvc.Versioning包，然后创建Swagger扩展方法封装多版本配置。在Program.cs中配置ApiVersioning和Swagger服务，支持查询字符串、URL路径、请求头和媒体类型等多种版本读取方式。通过创建不同版本的控制器（如V1和V2）并使用Route和ApiVersion特性标记，实现API版本隔离。最后在Swagger UI中可以查看和测试不同版本的API文档。这种方法有效解
借助 TX Text Control：在 .NET C# 中验证 PDF/UA 文档
开发者效率提升工具的博客
11-05 550
创建易于访问且符合规范的 PDF 文档正成为各行各业日益重要的需求。在本篇bow中，我们将探讨如何使用 Text Control 的 .NET 库验证 PDF/UA 文档，轻松确保生成的 PDF 符合无障碍标准。
C#类继承
yue008的博客
11-03 237
摘要：本文介绍了C#中的继承特性。C#只支持单继承，子类能访问父类的public和protected成员，但不能访问private成员。若父类是抽象类，需先继承再实例化。通过梯形面积计算的代码示例，展示了子类TrapeziaArea继承父类Trapezia后计算梯形面积的方法。继承实现了代码复用，同时通过访问修饰符控制成员的可见性。
第四阶段C#通讯开发-5：Socket与RS485 / Modbus联调
最新发布
m0_65011747的博客
11-05 343
（5）服务器的serialPort接收到真机传回的数据，并将数据传递给客户端。（1）串口通讯时，客户端通过RS485或Modbus进行通讯。（2）网口通讯的时候，客户端通过服务器获取真机的数。（4）服务器接收数据，并转发给真机。（6）客户端接收数据，并显示在页面。（2）实例化客户端，并连接服务端。（3）客户端发送问询帧到服务器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值