1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// 假设我们的原始业务数据是 32位整型 4660 (十六进制是 0x00001234)
int rawData = 0x1234; 

// 【获取高位 (MSB)】
// 原理：将整体向右平移 8 个坑位，把原本在前面的 0x12 挤到了最低位，同时必须配合 & 0xFF 杀死遗留的其他所有高位干扰
byte msb = (byte)((rawData >> 8) & 0xFF);  // 结果极其安全地变为: 0x12

// 【获取低位 (LSB)】
// 原理：无需平移，直接对原始数据怼上 0xFF的“漏网”，直接一刀切除前面所有的残渣，只留下最底下 8 位。
byte lsb = (byte)(rawData & 0xFF); // 结果被安详地切成: 0x34

// 发送时，如果是手册要求“高位在前”，你的发送缓冲区发车数组就长这样：
byte[] sendBuffer = new byte[] { msb, lsb }; // 发列车：[0x12, 0x34]

// 反过来！如果单片机硬件发给你了高低位被拆散的两个 byte，你该如何组合还原成十进制数字？
// 在工业控制源码中经常能够看到这种经典的位操作连写： short value = (short)((highByte << 8) | lowByte);
// 这是处理底层协议时 C# 的标准开发手势，其执行效率极高。

// 假设我们截获的物理数据参数如下：
byte highByte = 0x12; // 接收到的高位数据
byte lowByte = 0x34;  // 接收到的低位数据

// 【高低位组合原理深度拆解】
// 核心原理解析 1：利用左移运算符 (<< 8) 腾出低位
// byte 的最大限制为 255。当我们需要将其视作十进制的高位层级时，必须将 `highByte` 向左平移 8 个二进制位，为后续合并低位腾出空间！
// 例如 0x12 (即单纯二进制的 00010010) 左推八位后，变为了 0x1200 (即 00010010 00000000)。
// 请注意此时右方尾部：该数值后方的 8 个房间已经变为纯粹的 0 位了。

// 核心原理解析 2：利用按位或 (|) 执行安全的合并逻辑
// 注意此处建议使用 `|` 而非加法 `+`。将左移后的 0x1200 与 `lowByte` (此时低位自动补齐为 0x0034) 进行对齐按位或计算：
// 位运算物理法则为：“有 1 则为 1，双侧全 0 才是 0”。
// 移位后的高位：0x1200  (00010010 00000000)
//           | （执行按位或合并）
// 原始的低位：0x0034  (00000000 00110100)
// ===========================================
// 合成结果输出：0x1234  (00010010 00110100) -> 这种位运算相对算术加法更加安全，能够有效避免在特定极值或处理负标量时出现进位截断异常的风险。

// 核心原理解析 3：为何最外层需要包含强制类型转换 `(short)` ？
// 在 C# 中存在着隐式类型提升的规则防御机制：对于低于 `int` 的基本整型（如 byte, short）执行位移(<<)或按位运算(|)交互时，编译器为了防止因跨越长度溢出产生的异常丢失，会自动在后台把它们临时提升为 32位的 `int` 进行运算。
// 所以上述括号内运算产出的结果 0x1234，从类型上看其实已经是 32 位 `int` 整型 (存储形态为 0x00001234)。
// 由于目标是要将其正确存放进只有 16位 长度空间的系统类型抽屉里，因此必须在外层显式调用 `(short)`，向编译器宣称截取有意义的最右侧 16 位片段。

short finalValue = (short)((highByte << 8) | lowByte); // 原始仪器的真实参数彻底还原为 16 位整型：数字 4660。这种写法既安全可靠，又完美避免了利用 `BitConverter` 创建过多中间数组引发的 GC 压力。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public static class CrcTool
{
    // 固化的 Modbus CRC16 标准静态查表映射区域 (节约算法运算耗时开销)：
    private static readonly byte[] aucCRCHi = {
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, //... (剩余248个字典映射常量，实际项目请直接引入完整的数组表)
    };
    private static readonly byte[] aucCRCLo = {
        0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, //...
    };

    /// <summary>
    /// 核心方法：为数据帧生成并追加双字节通信校验码
    /// </summary>
    public static byte[] AppendCrc16(byte[] frameWithoutCrc)
    {
        // 步骤1：初始化寄存器缓冲值（Modbus 约定为 0xFFFF）
        byte crcHi = 0xFF; 
        byte crcLo = 0xFF; 
        
        // 步骤2：执行查表演变！遍历报文中每一位装载了配置的 byte 包裹数据：
        foreach (byte currentByte in frameWithoutCrc)
        {
            // 通过当前字节 与 原已保存的状态低位进行异或排量交叉，推导向下一步要查找的表偏移索引位置
            int index = crcLo ^ currentByte;
            
            // 使用拿到的页面序号翻查提取字典中算好的静态长串位阶影响，瞬间刷新替代现在两部分的高低位数值结果。
            crcLo = (byte)(crcHi ^ aucCRCHi[index]);
            crcHi = aucCRCLo[index];
        }

        // 步骤3：最终查表结算完毕，按需在尾部扩展 2 个字节的空间容量以容纳被追加的校验签名：
        byte[] finalFrame = new byte[frameWithoutCrc.Length + 2];
        Array.Copy(frameWithoutCrc, finalFrame, frameWithoutCrc.Length);

        // 步骤4【务必注意的重点】：追加校验封锁码。此处遵守工业 LSB First 字节序处理。
        // [先发低位，再发高位] 反逻辑组装：
        finalFrame[finalFrame.Length - 2] = crcLo; 
        finalFrame[finalFrame.Length - 1] = crcHi; 

        return finalFrame; 
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System.IO.Ports;
// ... (在初始化阶段)

SerialPort mySerialPort = new SerialPort();
mySerialPort.PortName = "COM3";
mySerialPort.BaudRate = 9600;
mySerialPort.DataBits = 8;
mySerialPort.StopBits = StopBits.One;
mySerialPort.Parity = Parity.None;

// 必须执行抛出 Open！这行代码才是真正霸占电脑上的物理 COM 口。如果口被别的软件占了，这里就会抛错！
try
{
    if (!mySerialPort.IsOpen)
    {
        mySerialPort.Open();
    }
}
catch (Exception ex)
{
    MessageBox.Show($"该串口可能被占用或不存在：{ex.Message}");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
using System;
using System.Text;
using System.IO.Ports;
using System.Windows.Forms;

public partial class SerialToolForm : Form
{
    private SerialPort _serialPort;

    public SerialToolForm()
    {
        InitializeComponent();
        
        _serialPort = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
        
        // 关键挂载！告诉系统一旦导线上有数据涌入，立刻喊醒后面的 SerialPort_DataReceived 方法干活！
        _serialPort.DataReceived += new SerialDataReceivedEventHandler(SerialPort_DataReceived);
        _serialPort.Open();
    }

    // ================== 【主动发送指令 (写串口)】 ==================
    private void btnSend_Click(object sender, EventArgs e)
    {
        if (!_serialPort.IsOpen) return;
        
        string rawText = txtSendInput.Text.Trim(); // 取出用户写入在界面的文字

        // 场景 A: 作为单纯的英文字符串字母发送出去
        if (radioButtonSendASCII.Checked)
        {
            // 将字母按照 ASCII 转为底层的物理数字字节！例如 "A" 会变成 65
            byte[] bytesToSend = Encoding.ASCII.GetBytes(rawText);
            _serialPort.Write(bytesToSend, 0, bytesToSend.Length);
            
            // （注：SerialPort 也有极其简单的封装 _serialPort.Write(rawText)）
        }
        // 场景 B: 作为高阶工程上的 16进制(Hex) 发送出去！
        else if (radioButtonSendHex.Checked)
        {
            // 如果用户在界面输入了 "01 03 00 01"，去掉空格后是 "01030001"
            string hexStr = rawText.Replace(" ", ""); 
            // 调用工具方法，真正地切片并转为四个 byte: [0x01, 0x03, 0x00, 0x01]
            byte[] hexBytes = HexStringToByteArray(hexStr);
            _serialPort.Write(hexBytes, 0, hexBytes.Length);
        }
    }

    // ================== 【被动接收捕获 (读串口)】 ==================
    private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
    {
        // 1. 探测现在池子里攒了多少个字节了？（解决拼包的基础）
        int bytesToReadCount = _serialPort.BytesToRead;
        byte[] receiveBuffer = new byte[bytesToReadCount];
        
        // 2. 将它们抽干净装到我们自己申请的水桶 receiveBuffer 里
        _serialPort.Read(receiveBuffer, 0, bytesToReadCount);

        string displayResult = "";

        // 3. 翻译截获到的底气水桶流（转为人类观看模式）
        if (radioButtonDisplayASCII.Checked)
        {
            // 根据 ASCII 表强行把 65 变回字母 "A"
            displayResult = Encoding.ASCII.GetString(receiveBuffer);
        }
        else if (radioButtonDisplayHex.Checked)
        {
            // 把原生的例如数字 255 展示成文本 "FF"，并且每两个字母空一格
            displayResult = BitConverter.ToString(receiveBuffer).Replace("-", " ");
        }

        // 4. 重中之重：返回 UI 主干道，更新界面的大文本框，避免死机！
        this.Invoke(new Action(() =>
        {
            // 拼接打印收到的车厢包裹，并且换行
            txtOutput.AppendText($"[接收到]: {displayResult} \r\n");
        }));
    }

    // --- 附送必备军火库工具：[十六进制文字文本]转[真实的物理Byte数组] ---
    private byte[] HexStringToByteArray(string s)
    {
        s = s.Replace(" ", ""); 
        byte[] buffer = new byte[s.Length / 2];
        for (int i = 0; i < s.Length; i += 2)
        {
            // 每次挖切两个字符 (例如 "0", "1")，作为 16进制 转回对应的数字 1。
            buffer[i / 2] = Convert.ToByte(s.Substring(i, 2), 16);
        }
        return buffer;
    }

    // Form 销毁时，切记将这个霸占系统底层资源的对象杀掉
    protected override void OnFormClosing(FormClosingEventArgs e)
    {
        if (_serialPort != null && _serialPort.IsOpen)
        {
            _serialPort.Close();
            _serialPort.Dispose();
        }
        base.OnFormClosing(e);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
using Modbus.Device;
using System.IO.Ports;
using System;
using System.Threading.Tasks;

// ... 注意，阻塞型的调用方法必须脱离 UI 主线程（如搭配 Task.Run 裹入任务包装），以防阻塞导致 Windows “由于未响应导致闪退”假象 ...

// 1. 启动并配置宣告底层基础串行通信设施口信息：
SerialPort port = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
try
{
    port.Open(); // 强制侵占锁定串行物理硬件资源握手对象
    
    // 2. 利用 NModbus4 工厂模式静态构筑桥接通信引擎：
    IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
    
    // 3. 通信稳定防护界限伞构建：设置物理层通信容忍缓冲限度：
    master.Transport.ReadTimeout = 1000;  // 必须加，防死卡顿！
    master.Transport.WriteTimeout = 1000; // 同上必设。
    master.Transport.Retries = 3;         // 通信容错重压请求上限 

    byte slaveId = 1; // 明确当前总线操作对象索引从地址。

    // === 下达物理功能操作指控信函 ===

    // 【情景 A】监控巡检器：拉取第 0 至 4 号（总共跨度为 5 个阵列长度）的线圈开合当前状况
    bool[] coilsInfo = master.ReadCoils(slaveId, 0, 5); 
    Console.WriteLine($"0号节点控制门的状态截取信号为反馈值即刻为：{coilsInfo[0]}");

    // 【情景 B】获取测量仪数值：抽取位置索引记录为 100 基础起始基准上的单个保持寄存器的内部承装记录值数据
    ushort[] registers = master.ReadHoldingRegisters(slaveId, 100, 1);
    Console.WriteLine($"截获在序号 100 的索引寄存器内部所含定额数值为：{registers[0]}");

    // 【情景 C】遥感操控硬件阀门：暴力要求将内部物理结构排行列里的第 2 号物理线圈控制枢纽当即接通（置高动作触发合闸运转）
    master.WriteSingleCoil(slaveId, 2, true); 

    // 【情景 D】运行时状态校准下达：强制把位于参数空间 50 号的配置预置参数直接改写成指令常数 8848 取代原封存在内的固化芯片老旧定额
    master.WriteSingleRegister(slaveId, 50, 8848); 
    
}
catch (TimeoutException tEx)
{
    // 如果 ReadTimeout 生效捕获了未曾响应的断点危机，其往往可以指示对方节点处于拔电，物理线体中断或者是单纯拨错了发送从设备ID导致的下位机协议未理会！
    Console.WriteLine($"传输超时触发安全下挂切断（请优先系统排查排查连接性质量是否过关）：{tEx.Message}");
}
catch (Exception ex)
{
    // 这个位置往往抛出的是严重的硬件物理访问性灾难事件
    Console.WriteLine($"底层总线条遭遇极其严峻的崩溃错误级：{ex.Message}");
}
finally
{
    // 收尾的硬法则原则：当一个完整通讯执行交互流程落幕或因为任何突发导致错误结束释放，务必第一时间对导线的排他使用特权进行切断废除。
    if (port.IsOpen) 
    {
        port.Close();
        port.Dispose();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

public class PureServer
{
    public async Task StartAsync()
    {
        // 1. 初始化 Socket，绑定通信凭证（网络协议族，字节流模式，TCP协议）
        Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        listener.Bind(new IPEndPoint(IPAddress.Any, 9000));
        listener.Listen(100); // 挂起连接队列（等待握手的最大缓冲量为 100）
        Console.WriteLine("服务端主干网已启动，持续异步监听在 9000 端口...");

        while (true)
        {
            // 2. 异步死等接客（使用 await 释放了当前线程资源池，极大地减轻 CPU 轮询负担，不会卡死主线程）
            Socket client = await listener.AcceptAsync();
            Console.WriteLine($"感知到新节点接入，硬件 IP 终点: {client.RemoteEndPoint}");

            // 3. 客户连入后，立刻派发一个专属后台独立监控任务展开一对一数据交互。
            // 迎宾员主循环瞬间完成交接，重回进入下一个 AcceptAsync 开始等待下一位客户防客。
            _ = Task.Run(() => HandleClientAsync(client)); 
        }
    }

    private async Task HandleClientAsync(Socket client)
    {
        var buffer = new byte[4096];
        try
        {
            while (true)
            {
                // 4. 异步接水（如果没数据来，这个 Task 会被挂起，把 CPU 让给别人，极度节省性能）
                // 现代 C# 的 Socket 异步推荐使用 ArraySegment 划定内存交互视窗
                int received = await client.ReceiveAsync(new ArraySegment<byte>(buffer), SocketFlags.None);

                // 5. 判断合规断开边界（收到属于 TCP 标准的零字节终止 FIN 塞子）
                if (received == 0)
                {
                    Console.WriteLine($"客户端已请求正常断开下线: {client.RemoteEndPoint}");
                    break;
                }

                // 6. 成功提取业务数据进行处理
                string msg = Encoding.UTF8.GetString(buffer, 0, received);
                Console.WriteLine($"收到客户端消息: {msg}");

                // 7. 发起反向数据答复通知
                byte[] sendData = Encoding.UTF8.GetBytes("服务器确认消息已收悉: " + msg);
                await client.SendAsync(new ArraySegment<byte>(sendData), SocketFlags.None);
            }
        }
        catch (SocketException ex)
        {
            Console.WriteLine($"客户探测产生异常掉线断裂: {ex.Message}");
        }
        finally
        {
            // 8. 优雅地善后：进行系统的生命周期物理防线释放与强制销毁关闭
            try { client.Shutdown(SocketShutdown.Both); } catch { }
            client.Close();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

public class PureClient
{
    public async Task ConnectAndCommunicateAsync()
    {
        Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        try
        {
            // 1. 发起非阻塞异步拨号，避免引发界面线程雪崩卡死
            await socket.ConnectAsync(IPAddress.Parse("127.0.0.1"), 9000);
            Console.WriteLine("TCP 拨号成功连通服务器主干！");

            // 2. 将来自远端下行数据的捕获抽离，甩入专门的独立异步循环侦听任务池中
            _ = Task.Run(() => ReceiveFromServerAsync(socket));

            // 3. 在当前节点内依旧保留主动抛送数据的轮询能力
            while (true)
            {
                string input = Console.ReadLine();
                if (input == "exit") break; // 用户输入 exit 指令申请退出

                byte[] data = Encoding.UTF8.GetBytes(input);
                await socket.SendAsync(new ArraySegment<byte>(data), SocketFlags.None);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"建联连接失败故障: {ex.Message}");
        }
        finally
        {
            // 4. 用户断开时，彻底清剿本地内存栈与通信端口资源
            try { socket.Shutdown(SocketShutdown.Both); } catch { }
            socket.Close();
            Console.WriteLine("物理级连接彻底注销。");
        }
    }

    private async Task ReceiveFromServerAsync(Socket socket)
    {
        var buffer = new byte[4096];
        try
        {
            while (true)
            {
                int received = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), SocketFlags.None);
                if (received == 0) break; // 服务单主动向我方挥手掉线/关服结束

                // 【进阶写法】：使用现代 C# 的 Span 语法，直接切片，性能更高！
                Span<byte> realData = buffer.AsSpan(0, received);
                
                Console.WriteLine("\n[服务端回话回函] " + Encoding.UTF8.GetString(realData));
            }
        }
        catch { /* 网络级断绝引发的崩溃链通常忽略作吞没处理即可 */ }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

public class ModernTcpServer
{
    public async Task StartModernServerAsync()
    {
        // 1. 无需关注底层网络协议参数，直白地宣布：在本地 IP (Any) 的 9000 端口接客
        TcpListener listener = new TcpListener(IPAddress.Any, 9000);
        listener.Start(); // 内部自动帮你执行了 Bind() 和 Listen()
        Console.WriteLine("现代 TCP 枢纽：挂载 9000 端口监听中...");

        while (true)
        {
            // 2. Accept 接客：但它返回的不再是底层的 Socket，而是被温柔包裹起来的 TcpClient！
            TcpClient connectedClient = await listener.AcceptTcpClientAsync();
            Console.WriteLine($"接获新宾客：{connectedClient.Client.RemoteEndPoint}");

            // 3. 剥离甩入独立接管车间处理 (防阻塞后续其他大批量的连入)
            _ = Task.Run(() => HandleModernClientAsync(connectedClient));
        }
    }

    private async Task HandleModernClientAsync(TcpClient client)
    {
        // 核心跃迁：不再直接调用 Socket.Receive()，而是提取一条抽象的流水管道 Stream！
        using NetworkStream stream = client.GetStream();
        byte[] buffer = new byte[1024];

        try
        {
            while (true)
            {
                // 通过标准流进行读取。它的代码感官体验就像在读写本地 txt 文件一样丝滑
                int byteCount = await stream.ReadAsync(buffer, 0, buffer.Length);
                if (byteCount == 0) break; // 对端掉线告辞

                string text = Encoding.UTF8.GetString(buffer, 0, byteCount);
                Console.WriteLine($"收到流文：{text}");
            }
        }
        catch { /* 被迫断线异常静默掉 */ }
        finally 
        { 
            client.Close(); // 统一安全销毁内部网络管道及附带的 Socket 资源
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using System;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

public class ModernTcpApp
{
    public async Task ConnectModernServerAsync()
    {
        using TcpClient client = new TcpClient();
        
        try
        {
            // 连底层的地址解析 IPAddress.Parse 都被框架默认吃掉了，你可以直接写入字符串地址和端口
            await client.ConnectAsync("127.0.0.1", 9000);
            
            // 引出属于你的那一段专属双向沟通流水线
            using NetworkStream stream = client.GetStream();
            
            byte[] data = Encoding.UTF8.GetBytes("Hello, 现代封装管线！");
            
            // 无需关注 SocketFlags.None，流 (Stream) 的使命就是纯粹且猛烈的读与写
            await stream.WriteAsync(data, 0, data.Length);
            await stream.FlushAsync(); // 确认流管道里的数据全部被推空且发出
            
            Console.WriteLine("发送结束，切出流隧道。");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"连接服务器受阻: {ex.Message}");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
private TcpListener _server;
private CancellationTokenSource _cts;
private bool _isServerRunning = false;

// UI 层按钮点击事件（例如绑定在 btnToggleServer）
private async void btnToggleServer_Click(object sender, EventArgs e)
{
    // [规范 1] 状态干预：禁用按钮，防止用户在执行过程中重复点击
    btnToggleServer.Enabled = false;

    if (!_isServerRunning)
    {
        // ---------------- 【服务器启动流程】 ----------------
        try
        {
            _server = new TcpListener(IPAddress.Any, 502);
            // 启用端口复用：确保在服务程序异常退出后重新启动时，可以直接复用原端口
            _server.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
            
            _server.Start();
            _isServerRunning = true;
            _cts = new CancellationTokenSource(); // 实例化取消令牌对象
            
            btnToggleServer.Text = "关闭服务器";
            btnToggleServer.BackColor = Color.LightGreen;
            
            // [规范 2] 异步监听：使用 Task.Run 将循环接收连接的任务放置在后台线程，避免阻塞 UI
            _ = Task.Run(() => AcceptClientsLoopAsync(_cts.Token));
        }
        catch (Exception ex)
        {
            MessageBox.Show($"网络服务启动失败: {ex.Message}");
            _isServerRunning = false;
        }
    }
    else
    {
        // ---------------- 【服务器停止流程】 ----------------
        try
        {
            // 通过令牌发送取消信号，中止各类依赖 Token 的等待过程
            _cts?.Cancel();
            
            // 关闭底层监听器，触发仍在阻塞中的 Accept 方法引发异常
            _server?.Stop();
        }
        catch { /* 处理停止过程中可能产生的已知通信异常 */ }
        finally
        {
            _isServerRunning = false;
            
            btnToggleServer.Text = "启动服务器";
            btnToggleServer.BackColor = Color.LightGray;
        }
    }

    // 状态切换完成，恢复界面交互控制权
    btnToggleServer.Enabled = true;
}

private async Task AcceptClientsLoopAsync(CancellationToken token)
{
    // 通过判断令牌是否发出了取消请求来控制主干循环
    while (!token.IsCancellationRequested)
    {
        try
        {
            // 等待远程连接。当调用界面的 _server.Stop() 时，此处会立刻引发底层的异常反馈中断等待
            TcpClient client = await _server.AcceptTcpClientAsync();
            
            // 收到外部设备连入后，分配独立后台任务作数据交互处理
            _ = Task.Run(() => { /* 执行接收数据流与业务操作... */ });
        }
        catch (ObjectDisposedException) { break; } // _server.Stop() 时触发的正常被动关闭情况
        catch (SocketException) { break; }         // 底层连接释放导致的报错中断
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

public class RawUdpTransceiver
{
    // === UDP 发送方 (极度纯粹的发射机制) ===
    public async Task SendFastStateWithRawSocketAsync()
    {
        // 1. 指定协议栈：InterNetwork (IPv4), Dgram (数据报模式), Udp 协议
        using Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        byte[] payload = Encoding.UTF8.GetBytes("设备 01 状态健康_28℃");
        
        // 2. 【核心差异】：完全不需要 Connect！
        // 因为没有专属隧道，所以每次发送都必须显式贴上“快递单”（明确指定目标 IPEndPoint）
        EndPoint targetAddress = new IPEndPoint(IPAddress.Parse("192.168.1.100"), 8888);
        
        // 使用 SendTo 抛出报文，抛出即代表任务结束（无论对端是否开机都不保证必达）
        await sender.SendToAsync(new ArraySegment<byte>(payload), SocketFlags.None, targetAddress);
        Console.WriteLine("底层 Socket：UDP 状态汇报抛射完成。");
    }

    // === UDP 接收方 (无需派发专属线程接客) ===
    public async Task StartRawUdpListenerAsync()
    {
        using Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        // 1. 绑定在本地路口的 8888 接口上
        listener.Bind(new IPEndPoint(IPAddress.Any, 8888));
        
        // 【核心差异】：没有 listener.Listen(100)！也没有 await listener.AcceptAsync()！
        Console.WriteLine("底层 Socket：UDP 接应站启动，直接开始接收一切途经 8888 口的数据包...");

        byte[] buffer = new byte[4096];
        EndPoint remoteSenderAddress = new IPEndPoint(IPAddress.Any, 0); // 准备一个空白信封用来装“发件人真实地址”

        while (true)
        {
            // 2. 因为各路神仙都可以往这个口扔包，所以必须用 ReceiveFrom，它会同时捕获数据和“寄件人具体坐标”
            SocketReceiveFromResult result = await listener.ReceiveFromAsync(
                new ArraySegment<byte>(buffer), SocketFlags.None, remoteSenderAddress);

            string stateMsg = Encoding.UTF8.GetString(buffer, 0, result.ReceivedBytes);
            Console.WriteLine($"收到从 {result.RemoteEndPoint} 发来的飞包: {stateMsg}");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

public class ModernUdpTransceiver
{
    // === UDP 发送方 ===
    public async Task SendFastStateAsync()
    {
        using UdpClient sender = new UdpClient();
        byte[] dgram = Encoding.UTF8.GetBytes("设备 01 状态健康_28℃");
        
        // 进一步精简封装，连 SocketFlags 之类的底层参数都隐藏了，直接填数据和对端地址点射
        await sender.SendAsync(dgram, dgram.Length, new IPEndPoint(IPAddress.Parse("192.168.1.100"), 8888));
    }

    // === UDP 接收方 ===
    public async Task StartUdpListenerAsync()
    {
        // 实例化时要求传入端口参数，底层会自动帮我们完成上面示例中的 Bind() 动作
        using UdpClient listener = new UdpClient(8888);

        while (true)
        {
            // ReceiveAsync 会返回一个结构体结果对象，既包含了核心载荷，也含有寄件人的 RemoteEndPoint
            UdpReceiveResult result = await listener.ReceiveAsync();
            string stateMsg = Encoding.UTF8.GetString(result.Buffer);
            
            Console.WriteLine($"收到从 {result.RemoteEndPoint} 发送的内容: {stateMsg}");
        }
    }
}

1
2
3
4
5
6
7
8
9
// 发送新请求前，如果底层缓冲区有遗留脏数据，直接全部读取并丢弃
if (client.Available > 0)
{
    byte[] junk = new byte[client.Available];
    stream.Read(junk, 0, junk.Length);
}

// 此时底层干净了，再安全地发送新报文
stream.Write(newRequestData, 0, newRequestData.Length);

1
2
3
4
5
6
7
8
// 在定时器或帧循环中高频触发：
if (client.Available > 0) 
{
    // 既然明确知道有数据，此时调用同步 Read 瞬间就能拿回数据，不会卡死界面
    int bytesToRead = client.Available;
    byte[] buffer = new byte[bytesToRead];
    stream.Read(buffer, 0, bytesToRead);
}

1
2
3
4
5
6
// 试图使用死循环干等 8 个字节的报文到达
while (client.Available < 8) 
{
    Thread.Sleep(10); 
}
stream.Read(buffer, 0, 8);

1
2
3
byte[] buffer = new byte[4096]; // 假设分配自资源池
// 指定索引区间，创建一个纯逻辑视图窗，无实际数组克隆
ArraySegment<byte> segment = new ArraySegment<byte>(buffer, 0, 8);

1
2
3
4
5
6
byte[] buffer = new byte[4096];
// 将数组映射为游标，通过坐标转移实现零损耗切片
Span<byte> span = buffer.AsSpan(0, 8); 

// 二次切割提取单独的功能码字节，全程没有新内存占用
Span<byte> functionCode = span.Slice(1, 1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 假设这是从 PipeReader 读出的数据，可能跨越了 3 个内存块
ReadOnlySequence<byte> sequence = buffer; 

// 把它丢给阅读器
SequenceReader<byte> reader = new SequenceReader<byte>(sequence);

// 尝试读取大端的 16 位整数
// 阅读器极其智能：
//   - 如果这 2 个字节刚好在同一个内存块 → 直接用 Span 读取（性能极高）
//   - 如果这 2 个字节刚好跨越了内存块（一块末尾，一块开头）→ 底层自动帮你安全拼接并读取！
if (reader.TryReadBigEndian(out short registerValue))
{
    Console.WriteLine($"读出数值: {registerValue}");
}

// 读取变长字符串（先读长度，再读内容）
if (reader.TryReadBigEndian(out int stringLength) && 
    reader.TryReadBytes(stringLength, out var text))
{
    Console.WriteLine($"字符串: {Encoding.UTF8.GetString(text)}");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
async Task ProcessPipelineAsync(PipeReader reader)
{
    while (true)
    {
        // 1. 从管道读取数据（可能跨越多个内存块）
        ReadResult result = await reader.ReadAsync();
        ReadOnlySequence<byte> buffer = result.Buffer;

        // 2. 尝试解析完整报文
        while (TryParseMessage(ref buffer, out var message))
        {
            // 处理业务
            ProcessMessage(message);
        }

        // 3. 标记已消费的位置（管道自动回收）
        reader.AdvanceTo(buffer.Start, buffer.End);

        // 4. 客户端断开
        if (result.IsCompleted) break;
    }
}

bool TryParseMessage(ref ReadOnlySequence<byte> buffer, out var message)
{
    var reader = new SequenceReader<byte>(buffer);

    // 读取固定头：2 字节 Type + 4 字节 Length
    if (!reader.TryReadBigEndian(out short type) || 
        !reader.TryReadBigEndian(out int length))
        return false;  // 数据不完整，等待更多数据

    // 验证数据完整性
    if (length > buffer.Length)
        return false;  // 粘包：还需要更多数据

    // 读取负载
    var payload = reader.Sequence.Slice(reader.Position, length);
    message = new Message { Type = type, Payload = payload };

    // 移动读位置
    reader.Advance(length);
    buffer = reader.Sequence;
    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
using System;
using System.Buffers;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;

// ---------- [维度 6: 生命周期] CancellationToken 终止令牌 ----------
// 任何合格的异步后端体系都必须具备全链路强制取消能力。
// 结合 CancellationToken，可以在宿主端点停止服务或用户点击“断开”时，立刻截停并释放底层的 ReceiveAsync 原生等待线程。

// ---------- [维度 5: 沟通桥梁] IProgress 契约 ----------
public class NetworkMessage
{
    public string ClientId { get; set; }
    public string Content { get; set; }
}

// ---------- [维度 4: 组织架构] Router 与 Handler ----------
public interface IMessageHandler
{
    void Handle(ReadOnlySpan<byte> payload, IProgress<NetworkMessage> progress);
}

public class TemperatureHandler : IMessageHandler
{
    public void Handle(ReadOnlySpan<byte> payload, IProgress<NetworkMessage> progress)
    {
        // 假设前两个字节代表业务数值
        short temp = BitConverter.ToInt16(payload.ToArray(), 0); // 注意：此处在 .NET Core 可直接传 Span
        progress?.Report(new NetworkMessage { Content = $"温度更新: {temp} ℃" });
    }
}

public class MessageRouter
{
    private readonly Dictionary<short, IMessageHandler> _routes = new();

    public void Register(short messageType, IMessageHandler handler) => _routes[messageType] = handler;

    public void Dispatch(short messageType, ReadOnlySpan<byte> payload, IProgress<NetworkMessage> progress)
    {
        if (_routes.TryGetValue(messageType, out var handler))
        {
            handler.Handle(payload, progress);
        }
        else
        {
            progress?.Report(new NetworkMessage { Content = $"未知的指令类型: {messageType}" });
        }
    }
}

// ---------- [维度 1, 2, 3: 链路、契约、后勤] 核心接收器 ----------
public class AdvancedSocketServer
{
    private readonly MessageRouter _router;
    private readonly IProgress<NetworkMessage> _progress;

    public AdvancedSocketServer(MessageRouter router, IProgress<NetworkMessage> progress)
    {
        _router = router;
        _progress = progress;
    }

    public async Task ProcessClientAsync(Socket client, CancellationToken cancellationToken)
    {
        // TLV 契约：2 字节 Type + 4 字节 Length
        const int HEADER_SIZE = 6; 
        byte[] headerBuffer = ArrayPool<byte>.Shared.Rent(HEADER_SIZE);

        try
        {
            while (true)
            {
                // 1. 物理链路读取头部，通过传入 CancellationToken，随时响应外部的强制下线中断
                int headerRead = await ReadExactAsync(client, headerBuffer, HEADER_SIZE, cancellationToken);
                if (headerRead == 0) break; // 客户端断开

                Span<byte> headerSpan = headerBuffer.AsSpan(0, HEADER_SIZE);
                short msgType = BitConverter.ToInt16(headerSpan.Slice(0, 2).ToArray(), 0);
                int payloadLength = BitConverter.ToInt32(headerSpan.Slice(2, 4).ToArray(), 0);

                // 2. 极致后勤借用负载载体
                byte[] bodyBuffer = ArrayPool<byte>.Shared.Rent(payloadLength);
                try
                {
                    int bodyRead = await ReadExactAsync(client, bodyBuffer, payloadLength, cancellationToken);
                    if (bodyRead == 0) break; 

                    ReadOnlySpan<byte> bodySpan = bodyBuffer.AsSpan(0, payloadLength);

                    // 3. 经过 Router 分发给对应的 Handler 进行业务隔离处理
                    _router.Dispatch(msgType, bodySpan, _progress);
                }
                finally
                {
                    ArrayPool<byte>.Shared.Return(bodyBuffer);
                }
            }
        }
        catch (OperationCanceledException)
        {
            _progress?.Report(new NetworkMessage { Content = "服务宿主已主动申请中止该通信链路。" });
        }
        catch (Exception ex)
        {
            _progress?.Report(new NetworkMessage { Content = $"连接异常: {ex.Message}" });
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(headerBuffer);
            client.Close();
        }
    }

    // 严谨的长度读取助手，支持 Cancellation 取消令牌防阻塞
    private async Task<int> ReadExactAsync(Socket socket, byte[] buffer, int size, CancellationToken token)
    {
        int totalRead = 0;
        while (totalRead < size)
        {
            // 在现代 .NET 中，利用 Memory<byte> 才能完整激活传入 CancellationToken 的原生支持
            int r = await socket.ReceiveAsync(buffer.AsMemory(totalRead, size - totalRead), SocketFlags.None, token);
            if (r == 0) return 0;
            totalRead += r;
        }
        return totalRead;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 1. 挂载路由规则与前台跨线程通信更新钩子
var progress = new Progress<NetworkMessage>(msg => textBlock.Text = msg.Content);
var router = new MessageRouter();
router.Register(0x01, new TemperatureHandler());

var server = new AdvancedSocketServer(router, progress);

// 2. 派发专门的取消掌控源
CancellationTokenSource _cts = new CancellationTokenSource();

// 用户点击连接（或接收到新客户端）时，启动后台挂载并丢入 Cancellation 凭证
_ = Task.Run(() => server.ProcessClientAsync(clientSocket, _cts.Token));

// 用户点击关闭连接大红按钮时，底层处于挂起等待的 ReceiveAsync 瞬间解锁并抛出中止异常！
_cts.Cancel();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System.Net.Sockets;
using System.Threading.Tasks;

public async Task StraightConnectAndFetchAsync()
{
    using TcpClient client = new TcpClient();
    await client.ConnectAsync("192.168.1.50", 502); 
    using NetworkStream stream = client.GetStream();

    // 构建一个完整的 Modbus TCP 读取线圈指令 (请求 0 号设备，读取功能码 0x01 的开关数，读3个引脚) 
    // 组成分析：[ 00 01 (自增事务ID) ] [ 00 00 (强制规定TCP为0) ] [ 00 06 (往后跟6个字节) ] 
    //            + [ 00 (站号) ] [ 01 (功能码) ] [ 00 00 00 03 (起始位+读取数量) ]
    byte[] tcpFrameRequest = { 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03 };
    
    // 1. 发射请求给设备
    await stream.WriteAsync(tcpFrameRequest, 0, tcpFrameRequest.Length);
    
    // 2. 独立异步留待接收设备的应答报文 
    // 注意实际由于网络延迟，读到的包可能会被分割，需参照上文五维体系架构进行切分与解析。
    byte[] responseBuffer = new byte[1024];
    int bytesRead = await stream.ReadAsync(responseBuffer, 0, responseBuffer.Length);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
using Modbus.Device;
using System.Net.Sockets;
using System.Threading.Tasks;

public async Task RequestDeviceViaModbusIpAsync()
{
    using TcpClient client = new TcpClient("192.168.1.50", 502);
    // 引擎更迭：直接产生用于网口传输且拥有自动构建 MBAP 头部序列化特性的网络端
    IModbusMaster ipMaster = ModbusIpMaster.CreateIp(client);
    
    // 底层的重试机制、MBAP组装与TCP包防波浪校验，均已被框架静默抽象。
    ushort[] holdingRegisters = await ipMaster.ReadHoldingRegistersAsync(1, 100, 5); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using System;

public class EnvironmentSensorParser
{
    // 获取从机 TCP/串口 转换穿透回传的物理原始温度流，比如由两个字节构成的连续位偏移位置信息
    public float ParseTemperaturePayload(byte[] rawPayload, int startOffset)
    {
        // 定制切片数组阶段：从给定切面提取装载信息的物理参数承载（占用2个字节位）
        byte[] tempSlice = { rawPayload[startOffset], rawPayload[startOffset + 1] };
        
        // 【防御卡点】：检验操作环境架构是否需要换向执行，防错乱读取！
        // 若当前宿主系统位权序列符合计算低阶端为头流结构的小端模式情况：
        if (BitConverter.IsLittleEndian)
        {
            // 通过环境判定后调用基础底层函数将 硬件设备网络流通发来的 高位先行倒排序转换为正确计算架构
            Array.Reverse(tempSlice); 
        }

        // 纠正执行整合还原：利用 BitConverter 将安全的端序队列还原构建回原生 16 位整型的内存格式数据
        ushort numericValue = BitConverter.ToUInt16(tempSlice, 0);

        // 工业传感器通常带有数值转换刻度补偿值，这往往是传递缩小系数放大值反馈（例如真实状况 28.5摄氏度，而上报流发出的则是 285）。
        return numericValue / 10f;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
using Modbus.Data;
using Modbus.Device;
using System.IO.Ports;
using System.Net;
using System.Net.Sockets;
using System.Threading.Tasks;

public class GatewayManager
{
    private DataStore _dataStore;
    private ModbusSlave _tcpSlave;

    public void StartGateway()
    {
        // 1. 创建全军最高级别的数据中转枢纽 (内存数据库)
        _dataStore = DataStoreFactory.CreateDefaultDataStore();

        // 2. 开启网络大门 (TCP 被动对外接客)
        TcpListener tcpListener = new TcpListener(IPAddress.Any, 502);
        
        // 重要防坑：防止死点残留导致强制重启报错 "一个端口只能用一次 (AddressAlreadyInUse)"
        tcpListener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        
        _tcpSlave = ModbusTcpSlave.CreateTcp(slaveId: 1, tcpListener);
        _tcpSlave.DataStore = _dataStore; // 【核心】：将内存池绑给接客网络服务！
        
        // 开始异步运行网络监听，脱离主线程
        Task.Run(() => _tcpSlave.Listen());

        // 3. 启动绝密刺客任务去底层抓取数据（这里以单发轮询示范）
        StartHardwarePollingTask();
    }

    private void StartHardwarePollingTask()
    {
        Task.Run(async () =>
        {
            using SerialPort port = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
            port.Open();
            
            IModbusSerialMaster hardwareMaster = ModbusSerialMaster.CreateRtu(port);
            hardwareMaster.Transport.ReadTimeout = 1000;

            while (true) // 永动机
            {
                try
                {
                    // [主站身份]：在底层的土路上向真实的下级机器要起步从 0 跨度长度为 10 的寄存器参数值
                    ushort[] rawData = hardwareMaster.ReadHoldingRegisters(1, 0, 10);
                    
                    // 将热乎的新鲜数据强行覆盖抹入系统的网关大内存池内
                    for (int i = 0; i < rawData.Length; i++)
                    {
                        // NModbus4 底层设计约定 DataStore 内部位图下标默认以 1 开始算 (因此+1)
                        _dataStore.HoldingRegisters[0 + i + 1] = rawData[i];
                    }
                }
                catch { /* 屏蔽因为串口偶发掉线等硬物理干扰导致的系统假死闪退故障 */ }

                // 强制要求喘息，以防把慢速物理导线给打满打卡死！
                await Task.Delay(1000); 
            }
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using Modbus.Device;
using System.IO.Ports;
using System.Threading.Tasks;

public async Task BuildAndInitRtuAsync()
{
    // [步骤一] 配置串口物理通讯参数
    // 参数含义依次为：端口号, 波特率, 奇偶校验, 数据位, 停止位
    using SerialPort port = new SerialPort("COM3", 9600, Parity.None, 8, StopBits.One);
    
    // [步骤二] 开启串口
    // 注意：串口为独占资源，如果被其他程序占用会抛出访问被拒异常。
    port.Open();

    // [步骤三] 初始化 NModbus4 主站实例
    // 该库将自动处理目标 SlaveID 包装，并在报文末尾附加 CRC16 校验码。
    IModbusMaster master = ModbusSerialMaster.CreateRtu(port);

    // [参数配置] 设定超时与重试时间
    master.Transport.ReadTimeout = 500;  // 设定读取超时时间为 500ms
    master.Transport.Retries = 2;        // 设定失败重试次数为 2 次以应对偶发信噪干扰
    
    // 发送写入指令：向 1 号从站的 0 地址位写入线圈闭合状态
    await master.WriteSingleCoilAsync(1, 0, true);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using Modbus.Device;
using System.Net.Sockets;
using System.Threading.Tasks;

public async Task BuildAndInitTcpAsync()
{
    using TcpClient client = new TcpClient();

    // [步骤一] TCP 握手与连接建立
    // 直接连接离线 IP 会导致默认的较长超时阻塞，建议使用 Task.WhenAny 包装建立明确的超时熔断机制。
    var connectTask = client.ConnectAsync("192.168.0.100", 502);
    if (await Task.WhenAny(connectTask, Task.Delay(2000)) != connectTask)
         throw new TimeoutException("尝试连接目标设备超时。");

    // [步骤二] 抽象底层连接实例
    // TCP 协议在报文前部添加 6 字节 MBAP 头部，并移除了串口的尾部 CRC 序列。
    IModbusMaster master = ModbusIpMaster.CreateIp(client);
    
    // 配置长连接读写超时预警（避免线程死锁挂起）
    master.Transport.ReadTimeout = 1000;

    // 建议：对于工业监控体系常态化服务，不要在单词操作后立即调用 client.Close()，应由主程长效保有该 client 单例，进行定时任务轮询读取即可防止频繁耗费连接重建资源。
    
    // 对指定地址读请求
    ushort[] val = await master.ReadHoldingRegistersAsync(1, 100, 2);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using Modbus.Device;
using System.Net.Sockets;
using System.Threading.Tasks;

public async Task BuildAndInitUdpAsync()
{
    // [步骤一] UDP 客户端初始化
    // 实例化 UDP 容器过程本身不产生网络数据交互。
    using UdpClient client = new UdpClient();
    
    // 此处的 Connect 并不执行真实的网络三次握手建立连接，而是锁定投递的默认目标终点站。
    client.Connect("192.168.0.222", 502); 

    // [步骤二] 生成 Modbus IP 驱动包装 
    // 发送的数据与 TCP 保持一致结构（含 MBAP 头，无 CRC），仅传递层的传输协议由流变更为数据报模式。
    IModbusMaster master = ModbusIpMaster.CreateIp(client);
    
    // [重要参数配置] 必须设定严格明确的读取超时控制
    // 由于 UDP 本身无法感知连接断开事件，必须通过设置 ReadTimeout 保障服务能在远端设备下线不回包时主动熔断异常。
    master.Transport.ReadTimeout = 300; 

    // 执行寄存器拉取动作
    ushort[] val = await master.ReadHoldingRegistersAsync(1, 200, 10);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System.IO.Ports;

// 1. 初始化并打开串口
using SerialPort port = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
port.Open();

// 2. 发送请求帧（需包含完整的数据主体与 CRC 校验码）
byte[] rawBytes = { ... }; 
port.Write(rawBytes, 0, rawBytes.Length);

// 3. 通过事件监听接收数据
port.DataReceived += (s, e) => 
{
    // 获取当前缓冲区内的可用字节数
    int bytesToRead = port.BytesToRead;
    byte[] buffer = new byte[bytesToRead];
    port.Read(buffer, 0, bytesToRead);
    // 此处接收到的 buffer 即为包含两字节 CRC 尾部的完整响应帧
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
byte[] MakeRtuPayload()
{
    // 核心载荷：[从机号01] [读寄存器03] [起始地址 00 00] [读取数量 00 02]
    byte[] core = new byte[] { 0x01, 0x03, 0x00, 0x00, 0x00, 0x02 };
    
    // 计算 CRC16 校验码，注意结果通常使用小端序（低位在前，高位在后）
    byte[] crcBytes = CalculateCrc16(core); // 假设计算结果为 0xC4, 0x0B
    
    // 拼接成完整的 8 字节数据帧
    byte[] finalFrame = new byte[8];
    Array.Copy(core, 0, finalFrame, 0, 6);
    finalFrame[6] = crcBytes[0]; 
    finalFrame[7] = crcBytes[1]; 
    
    return finalFrame; // 随后可通过 port.Write 发送至串口
}

1
2
3
4
5
6
7
8
9
10
11
12
void ParseRtuResponse(byte[] buffer)
{
    // 第一步：提取前 N-2 个字节计算 CRC，并与尾部两字节进行比对，验证数据完整性。
    
    // 第二步：读取第 3 个字节（下标为 2），获取后续有效数据的准确长度。
    int dataLength = buffer[2];
    
    // 第三步：使用 Span<byte> 跳过前三字节的协议头信息，切片获取核心数据区。
    Span<byte> realData = buffer.AsSpan(3, dataLength);
    
    // 第四步：若网络设备采用大端网络字节序，而在小端系统下解析，需使用 Array.Reverse 转换字节序后再转为整型或浮点型数据。
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using System.Net.Sockets;

// 1. 建立 TCP 连接
using TcpClient client = new TcpClient();
await client.ConnectAsync("192.168.1.100", 502);
using NetworkStream stream = client.GetStream(); 

// 2. 发送带有 MBAP 头的写入流
byte[] rawBytes = { ... }; 
await stream.WriteAsync(rawBytes, 0, rawBytes.Length);

// 3. 异步读取 TCP 响应数据
byte[] buffer = new byte[1024];
int readCount = await stream.ReadAsync(buffer, 0, buffer.Length);
// 此处的 tcpBuffer 包含了完整的 MBAP 头部信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
byte[] MakeTcpPayload()
{
    // MBAP 前缀（固定占用 6 字节）：
    // [2字节事务标识符 00 01] + [2字节协议标识符 00 00] + [2字节后续报文总长度 00 06]
    byte[] mbap = new byte[] { 0x00, 0x01, 0x00, 0x00, 0x00, 0x06 };
    
    // 基础操作载荷（无需附加 CRC，共计 6 字节）
    byte[] core = new byte[] { 0x01, 0x03, 0x00, 0x00, 0x00, 0x02 };
    
    byte[] finalFrame = new byte[12];
    Array.Copy(mbap, 0, finalFrame, 0, 6);
    Array.Copy(core, 0, finalFrame, 6, 6);
    
    return finalFrame; // 随后交由 stream.WriteAsync 执行网络发送
}

1
2
3
4
5
6
7
8
9
void ParseTcpResponse(byte[] buffer)
{
    // 服务器响应的报文结构前置部分必然为：[MBAP 6字节] + [1字节从机地址] + [1字节功能码]
    // 因此，第 9 个字节（下标索引 8）即指示“有效数据长度信息”
    int dataLength = buffer[8]; 
    
    // 配合 Span 切片特性，跳过前 9 个字节的协议头部区域，直接提取实质数据段
    Span<byte> realData = buffer.AsSpan(9, dataLength);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System.Net.Sockets;
using System.Net;

// 1. 初始化 UDP 客户端组件（无 Connect 握手过程）
using UdpClient client = new UdpClient();

// 2. 定向发送：复用基于 MBAP 结构化打包生成的 12 字节报文进行 UDP 投递
byte[] mpabWrappedBytes = MakeTcpPayload(); // 报文内容机制同 TCP
await client.SendAsync(mpabWrappedBytes, mpabWrappedBytes.Length, new IPEndPoint(IPAddress.Parse("192.168.1.100"), 502));

// 3. 异步监听接收网络 UDP 数据包
UdpReceiveResult result = await client.ReceiveAsync();

// 后续针对 result.Buffer 的解析动作，可以直接调用与 ParseTcpResponse 相同的位运算或切片提取逻辑处理。

1
2
3
4
5
6
7
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint(IPAddress.Any, 502);
server.Bind(ep);
server.Listen(10); 
Socket clientSocket = server.Accept();
byte[] buffer = new byte[1024];
int count = clientSocket.Receive(buffer);

1
2
3
4
5
6
TcpListener listener = new TcpListener(IPAddress.Any, 502);
listener.Start();
TcpClient client = listener.AcceptTcpClient();
NetworkStream stream = client.GetStream();
byte[] buffer = new byte[1024];
int count = stream.Read(buffer, 0, buffer.Length); 

1
2
3
4
5
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("192.168.1.100"), 502);
client.Connect(ep);
byte[] data = { 0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x09 };
client.Send(data);

1
2
3
4
TcpClient client = new TcpClient("192.168.1.100", 502);
byte[] data = { 0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x09 };
NetworkStream stream = client.GetStream();
stream.Write(data, 0, data.Length);

1
2
3
4
5
Socket udpServer = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
udpServer.EnableBroadcast = true;
byte[] data = Encoding.UTF8.GetBytes("Hello");
IPEndPoint broadcastEP = new IPEndPoint(IPAddress.Broadcast, 8888);
udpServer.SendTo(data, broadcastEP);

1
2
3
4
5
UdpClient udp = new UdpClient();
udp.EnableBroadcast = true;
byte[] data = Encoding.UTF8.GetBytes("Hello");
IPEndPoint broadcastEP = new IPEndPoint(IPAddress.Broadcast, 8888);
udp.Send(data, data.Length, broadcastEP);

1
2
3
4
5
6
7
Socket udpServer = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
IPEndPoint localEP = new IPEndPoint(IPAddress.Any, 8888);
udpServer.Bind(localEP);

byte[] buffer = new byte[1024];
EndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0); // 用于存放发送方的终点容器
int count = udpServer.ReceiveFrom(buffer, ref remoteEP);

1
2
3
UdpClient udp = new UdpClient(8888);
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
byte[] data = udp.Receive(ref remoteEP);

1
2
3
4
Socket udpClient = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
byte[] data = Encoding.UTF8.GetBytes("Command");
IPEndPoint targetEP = new IPEndPoint(IPAddress.Parse("192.168.1.100"), 502);
udpClient.SendTo(data, targetEP);

1
2
3
4
5
UdpClient udp = new UdpClient();
// 开启面向底层的“伪连接”，告知底层接下来的默认通讯抛射点
udp.Connect("192.168.1.100", 502); 
byte[] data = Encoding.UTF8.GetBytes("Command");
udp.Send(data, data.Length);

1
2
3
4
5
6
7
8
9
10
11
12
13
// ① 创建工厂（MQTTnet 统一入口）
var factory = new MqttFactory();

// ② 构建配置（端口、连接数等）
var serverOptions = new MqttServerOptionsBuilder()
    .WithDefaultEndpoint()            // 启用 TCP，默认 1883
    .WithDefaultEndpointPort(1883)
    .Build();

// ③ 创建并启动
var server = factory.CreateMqttServer(serverOptions);
await server.StartAsync();
Console.WriteLine("Broker 已就绪，监听 :1883");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 【1】连接鉴权 - 第一道安全门
server.ValidatingConnectionAsync += e =>
{
    Console.WriteLine($"[{e.ClientId}] 尝试连接，用户={e.UserName}");
    // 密码错误则拒绝
    if (e.Password != "secret123")
        e.ReasonCode = MQTTnet.Protocol.MqttConnectReasonCode.BadUserNameOrPassword;
    return Task.CompletedTask;
};

// 【2】消息拦截 - 可修改/丢弃/记录
server.InterceptingPublishAsync += e =>
{
    Console.WriteLine($"[拦截] {e.ClientId} → {e.ApplicationMessage.Topic}");
    // e.ProcessPublish = false;  // 阻止转发
    return Task.CompletedTask;
};

// 【3-4】连接/断开通知
server.ClientConnectedAsync    += e => Console.WriteLine($"+ {e.ClientId}");
server.ClientDisconnectedAsync += e => Console.WriteLine($"- {e.ClientId}");