C#实现串口通信的四种灵活策略和避坑指南_Asp.net

前言

工业控制、物联网设备通信中，是否遇到过这样的场景：向设备发送一个简单的查询指令，却发现返回的数据总是"分批到达"？明明应该收到完整的20字节响应，却只能收到几个零散的数据包？

别急，这不是你的代码有问题！

这是串口通信中最常见的"分包接收"现象。设备可能一次发送10字节，下一次发送剩余的10字节，而我们的程序却不知道什么时候才算接收完成。

今天我们就来彻底解决这个让无数 c# 开发头疼的问题！

为什么会分包接收

根本原因

串口通信是异步的，数据传输会受到以下因素影响：

硬件缓冲区大小限制

设备处理速度差异

网络延迟（对于串口转以太网设备）

系统调度

这些因素导致原本连续的数据流被操作系统或中间设备拆分成多个小块，逐次送达应用程序。

传统方案的痛点

// ❌ 错误示例：只能收到第一包数据
serialport.write(command, 0, command.length);
thread.sleep(100); // 固定等待时间
byte[] buffer = new byte[1024];
int count = serialport.read(buffer, 0, 1024); // 可能只读到部分数据

这种写法的问题包括：

固定等待时间不可靠

无法判断数据是否接收完整

容易丢失后续数据包

四种灵活接收策略

为应对不同应用场景，我们设计了以下四种策略：

方案一：数据间隔超时判断（⭐推荐）

适用场景：不知道数据长度，但设备发送完毕后会有明显时间间隔。

public byte[] sendquerywithgaptimeout(byte[] command, int gaptimeoutms = 100, int maxwaitms = 3000)
{
    // 清空缓冲区并开始接收
    lock (bufferlock)
    {
        receivedbuffer.clear();
        iswaitingforresponse = true;
        lastreceivetime = datetime.now;
    }
    // 发送指令
    serialport.write(command, 0, command.length);
    
    datetime starttime = datetime.now;
    
    while ((datetime.now - starttime).totalmilliseconds < maxwaitms)
    {
        thread.sleep(10);
        
        lock (bufferlock)
        {
            // 🔥 关键逻辑：有数据且间隔超时则认为接收完成
            if (receivedbuffer.count > 0 && 
                (datetime.now - lastreceivetime).totalmilliseconds > gaptimeoutms)
            {
                iswaitingforresponse = false;
                return receivedbuffer.toarray();
            }
        }
    }
    
    return null;
}

实际业务中，这个能解决大部分问题。

方案二：结束符判断

适用场景：数据以特定字符结尾（如 \r\n、\0 等）。

public byte[] sendquerywithendmarker(byte[] command, byte[] endmarker, int maxwaitms = 3000)
{
    // ... 发送逻辑相同 ...
    
    while ((datetime.now - starttime).totalmilliseconds < maxwaitms)
    {
        lock (bufferlock)
        {
            if (receivedbuffer.count >= endmarker.length)
            {
                // 🔥 检查缓冲区末尾是否包含结束标记
                bool foundendmarker = true;
                for (int i = 0; i < endmarker.length; i++)
                {
                    if (receivedbuffer[receivedbuffer.count - endmarker.length + i] != endmarker[i])
                    {
                        foundendmarker = false;
                        break;
                    }
                }
                
                if (foundendmarker)
                {
                    return receivedbuffer.toarray();
                }
            }
        }
    }
}

方案三：协议帧结构判断

适用场景：数据有固定帧头和长度字段（如 modbus 协议）。

public byte[] sendquerywithframeprotocol(byte[] command, byte frameheader, int lengthfieldoffset, int lengthfieldsize = 1)
{
    // ... 发送逻辑 ...
    
    while (/* 超时检查 */)
    {
        lock (bufferlock)
        {
            if (receivedbuffer.count > lengthfieldoffset + lengthfieldsize)
            {
                // 检查帧头
                if (receivedbuffer[0] == frameheader)
                {
                    // 🔥 从长度字段获取数据长度
                    int datalength = lengthfieldsize == 1 ? 
                        receivedbuffer[lengthfieldoffset] : 
                        (receivedbuffer[lengthfieldoffset] << 8) | receivedbuffer[lengthfieldoffset + 1];
                    
                    int expectedframelength = lengthfieldoffset + lengthfieldsize + datalength;
                    
                    if (receivedbuffer.count >= expectedframelength)
                    {
                        return receivedbuffer.take(expectedframelength).toarray();
                    }
                }
            }
        }
    }
}

方案四：组合策略（⭐⭐推荐）

最灵活的方案，同时使用多种判断条件：

public byte[] sendquerywithcombinedstrategy(byte[] command,
    int gaptimeoutms = 100,     // 数据间隔超时
    byte[] endmarker = null,    // 结束标记  
    int? maxlength = null,      // 最大长度限制
    int maxwaitms = 3000)       // 总超时时间
{
    // ... 发送逻辑 ...
    
    while (/* 总超时检查 */)
    {
        lock (bufferlock)
        {
            if (receivedbuffer.count == 0) continue;
            
            // 🔥 条件1：达到最大长度限制
            if (maxlength.hasvalue && receivedbuffer.count >= maxlength.value)
                return receivedbuffer.toarray();
            
            // 🔥 条件2：发现结束标记
            if (endmarker != null && /* 检查结束标记逻辑 */)
                return receivedbuffer.toarray();
            
            // 🔥 条件3：数据间隔超时
            if ((datetime.now - lastreceivetime).totalmilliseconds > gaptimeoutms)
                return receivedbuffer.toarray();
        }
    }
}

核心机制：数据接收事件

所有策略都依赖于统一的数据接收事件处理：

private void ondatareceived(object sender, serialdatareceivedeventargs e)
{
    if (!iswaitingforresponse) return;
    try
    {
        int bytestoread = serialport.bytestoread;
        if (bytestoread > 0)
        {
            byte[] buffer = new byte[bytestoread];
            int bytesread = serialport.read(buffer, 0, bytestoread);
            lock (bufferlock)
            {
                receivedbuffer.addrange(buffer);
                lastreceivetime = datetime.now; // 🔥 更新最后接收时间
                console.writeline($"收到数据包 ({bytesread} 字节): {bitconverter.tostring(buffer, 0, bytesread)}");
            }
        }
    }
    catch (exception ex)
    {
        console.writeline($"数据接收异常: {ex.message}");
    }
}

完整代码

using system;
using system.collections.generic;
using system.io.ports;
using system.linq;
using system.text;
using system.threading.tasks;

namespace appflexserialport
{
    internal class flexibleserialport
    {
        private serialport serialport;
        private list<byte> receivedbuffer;
        private readonly object bufferlock = new object();
        private timer timeouttimer;
        private bool iswaitingforresponse = false;
        private datetime lastreceivetime;
        private readonly int datagaptimeout = 100; // 数据间隔超时时间(ms)

        public flexibleserialport()
        {
            receivedbuffer = new list<byte>();
        }

        /// <summary>
        /// 初始化串口
        /// </summary>
        public bool initializeport(string portname = "com1", int baudrate = 9600,
            parity parity = parity.none, int databits = 8, stopbits stopbits = stopbits.one)
        {
            try
            {
                serialport = new serialport(portname, baudrate, parity, databits, stopbits);
                serialport.readtimeout = 1000;
                serialport.writetimeout = 1000;
                serialport.datareceived += ondatareceived;
                serialport.open();
                console.writeline($"串口 {portname} 已成功打开");
                return true;
            }
            catch (exception ex)
            {
                console.writeline($"串口初始化失败: {ex.message}");
                return false;
            }
        }

        /// <summary>
        /// 方案1: 基于数据间隔超时判断接收完成
        /// 适用于：不知道数据长度，但设备发送完后会有明显的时间间隔
        /// </summary>
        public byte[] sendquerywithgaptimeout(byte[] command, int gaptimeoutms = 100, int maxwaitms = 3000)
        {
            if (serialport == null || !serialport.isopen)
            {
                console.writeline("串口未打开");
                return null;
            }
            lock (bufferlock)
            {
                receivedbuffer.clear();
                iswaitingforresponse = true;
                lastreceivetime = datetime.now;
            }
            try
            {
                // 发送查询指令
                serialport.write(command, 0, command.length);
                console.writeline($"已发送查询指令: {bitconverter.tostring(command)}");
                datetime starttime = datetime.now;
                datetime lastchecktime = datetime.now;
                int lastbuffersize = 0;
                while ((datetime.now - starttime).totalmilliseconds < maxwaitms)
                {
                    thread.sleep(10);
                    lock (bufferlock)
                    {
                        // 如果有数据且数据间隔超过指定时间，认为接收完成
                        if (receivedbuffer.count > 0 &&
                            (datetime.now - lastreceivetime).totalmilliseconds > gaptimeoutms)
                        {
                            iswaitingforresponse = false;
                            byte[] result = receivedbuffer.toarray();
                            console.writeline($"基于间隔超时判断接收完成，共收到 {result.length} 字节");
                            return result;
                        }
                    }
                }
                // 最大等待时间超时
                iswaitingforresponse = false;
                lock (bufferlock)
                {
                    if (receivedbuffer.count > 0)
                    {
                        byte[] result = receivedbuffer.toarray();
                        console.writeline($"最大等待时间超时，收到 {result.length} 字节");
                        return result;
                    }
                }
                console.writeline("接收超时，未收到任何数据");
                return null;
            }
            catch (exception ex)
            {
                console.writeline($"发送指令失败: {ex.message}");
                iswaitingforresponse = false;
                return null;
            }
        }

        /// <summary>
        /// 方案2: 基于结束符判断接收完成
        /// 适用于：数据以特定字符或字节序列结尾
        /// </summary>
        public byte[] sendquerywithendmarker(byte[] command, byte[] endmarker, int maxwaitms = 3000)
        {
            if (serialport == null || !serialport.isopen)
            {
                console.writeline("串口未打开");
                return null;
            }
            lock (bufferlock)
            {
                receivedbuffer.clear();
                iswaitingforresponse = true;
            }
            try
            {
                serialport.write(command, 0, command.length);
                console.writeline($"已发送查询指令: {bitconverter.tostring(command)}");
                datetime starttime = datetime.now;
                while ((datetime.now - starttime).totalmilliseconds < maxwaitms)
                {
                    thread.sleep(10);
                    lock (bufferlock)
                    {
                        if (receivedbuffer.count >= endmarker.length)
                        {
                            // 检查缓冲区末尾是否包含结束标记
                            bool foundendmarker = true;
                            for (int i = 0; i < endmarker.length; i++)
                            {
                                if (receivedbuffer[receivedbuffer.count - endmarker.length + i] != endmarker[i])
                                {
                                    foundendmarker = false;
                                    break;
                                }
                            }
                            if (foundendmarker)
                            {
                                iswaitingforresponse = false;
                                byte[] result = receivedbuffer.toarray();
                                console.writeline($"发现结束标记，接收完成，共收到 {result.length} 字节");
                                return result;
                            }
                        }
                    }
                }
                // 超时处理
                iswaitingforresponse = false;
                lock (bufferlock)
                {
                    if (receivedbuffer.count > 0)
                    {
                        byte[] result = receivedbuffer.toarray();
                        console.writeline($"等待结束标记超时，收到 {result.length} 字节");
                        return result;
                    }
                }
                return null;
            }
            catch (exception ex)
            {
                console.writeline($"发送指令失败: {ex.message}");
                iswaitingforresponse = false;
                return null;
            }
        }

        /// <summary>
        /// 方案3: 基于协议帧结构判断接收完成
        /// 适用于：数据有固定的帧头和长度字段
        /// </summary>
        public byte[] sendquerywithframeprotocol(byte[] command, byte frameheader, int lengthfieldoffset,
            int lengthfieldsize = 1, int maxwaitms = 3000)
        {
            if (serialport == null || !serialport.isopen)
            {
                console.writeline("串口未打开");
                return null;
            }
            lock (bufferlock)
            {
                receivedbuffer.clear();
                iswaitingforresponse = true;
            }
            try
            {
                serialport.write(command, 0, command.length);
                console.writeline($"已发送查询指令: {bitconverter.tostring(command)}");
                datetime starttime = datetime.now;
                while ((datetime.now - starttime).totalmilliseconds < maxwaitms)
                {
                    thread.sleep(10);
                    lock (bufferlock)
                    {
                        if (receivedbuffer.count > lengthfieldoffset + lengthfieldsize)
                        {
                            // 检查帧头
                            if (receivedbuffer[0] == frameheader)
                            {
                                // 获取数据长度
                                int datalength = 0;
                                if (lengthfieldsize == 1)
                                {
                                    datalength = receivedbuffer[lengthfieldoffset];
                                }
                                else if (lengthfieldsize == 2)
                                {
                                    datalength = (receivedbuffer[lengthfieldoffset] << 8) | receivedbuffer[lengthfieldoffset + 1];
                                }
                                int expectedframelength = lengthfieldoffset + lengthfieldsize + datalength;
                                if (receivedbuffer.count >= expectedframelength)
                                {
                                    iswaitingforresponse = false;
                                    byte[] result = receivedbuffer.take(expectedframelength).toarray();
                                    console.writeline($"根据帧长度判断接收完成，共收到 {result.length} 字节");
                                    return result;
                                }
                            }
                        }
                    }
                }
                // 超时处理
                iswaitingforresponse = false;
                lock (bufferlock)
                {
                    if (receivedbuffer.count > 0)
                    {
                        byte[] result = receivedbuffer.toarray();
                        console.writeline($"帧协议解析超时，收到 {result.length} 字节");
                        return result;
                    }
                }
                return null;
            }
            catch (exception ex)
            {
                console.writeline($"发送指令失败: {ex.message}");
                iswaitingforresponse = false;
                return null;
            }
        }

        /// <summary>
        /// 方案4: 组合策略 - 最灵活的方案
        /// 同时使用多种判断条件，任一条件满足就结束接收
        /// </summary>
        public byte[] sendquerywithcombinedstrategy(byte[] command,
            int gaptimeoutms = 100,
            byte[] endmarker = null,
            int? maxlength = null,
            int maxwaitms = 3000)
        {
            if (serialport == null || !serialport.isopen)
            {
                console.writeline("串口未打开");
                return null;
            }
            lock (bufferlock)
            {
                receivedbuffer.clear();
                iswaitingforresponse = true;
                lastreceivetime = datetime.now;
            }
            try
            {
                serialport.write(command, 0, command.length);
                console.writeline($"已发送查询指令: {bitconverter.tostring(command)}");
                datetime starttime = datetime.now;
                while ((datetime.now - starttime).totalmilliseconds < maxwaitms)
                {
                    thread.sleep(10);
                    lock (bufferlock)
                    {
                        if (receivedbuffer.count == 0) continue;
                        // 条件1: 检查最大长度限制
                        if (maxlength.hasvalue && receivedbuffer.count >= maxlength.value)
                        {
                            iswaitingforresponse = false;
                            byte[] result = receivedbuffer.toarray();
                            console.writeline($"达到最大长度限制，接收完成，共收到 {result.length} 字节");
                            return result;
                        }
                        // 条件2: 检查结束标记
                        if (endmarker != null && receivedbuffer.count >= endmarker.length)
                        {
                            bool foundendmarker = true;
                            for (int i = 0; i < endmarker.length; i++)
                            {
                                if (receivedbuffer[receivedbuffer.count - endmarker.length + i] != endmarker[i])
                                {
                                    foundendmarker = false;
                                    break;
                                }
                            }
                            if (foundendmarker)
                            {
                                iswaitingforresponse = false;
                                byte[] result = receivedbuffer.toarray();
                                console.writeline($"发现结束标记，接收完成，共收到 {result.length} 字节");
                                return result;
                            }
                        }
                        // 条件3: 检查数据间隔超时
                        if ((datetime.now - lastreceivetime).totalmilliseconds > gaptimeoutms)
                        {
                            iswaitingforresponse = false;
                            byte[] result = receivedbuffer.toarray();
                            console.writeline($"数据间隔超时，接收完成，共收到 {result.length} 字节");
                            return result;
                        }
                    }
                }
                // 最大等待时间超时
                iswaitingforresponse = false;
                lock (bufferlock)
                {
                    if (receivedbuffer.count > 0)
                    {
                        byte[] result = receivedbuffer.toarray();
                        console.writeline($"最大等待时间超时，收到 {result.length} 字节");
                        return result;
                    }
                }
                return null;
            }
            catch (exception ex)
            {
                console.writeline($"发送指令失败: {ex.message}");
                iswaitingforresponse = false;
                return null;
            }
        }

        /// <summary>
        /// 数据接收事件处理
        /// </summary>
        private void ondatareceived(object sender, serialdatareceivedeventargs e)
        {
            if (!iswaitingforresponse) return;
            try
            {
                int bytestoread = serialport.bytestoread;
                if (bytestoread > 0)
                {
                    byte[] buffer = new byte[bytestoread];
                    int bytesread = serialport.read(buffer, 0, bytestoread);
                    lock (bufferlock)
                    {
                        receivedbuffer.addrange(buffer);
                        lastreceivetime = datetime.now; // 更新最后接收时间
                        console.writeline($"收到数据包 ({bytesread} 字节): {bitconverter.tostring(buffer, 0, bytesread)}");
                        console.writeline($"当前缓冲区总计: {receivedbuffer.count} 字节");
                    }
                }
            }
            catch (exception ex)
            {
                console.writeline($"数据接收处理异常: {ex.message}");
            }
        }

        /// <summary>
        /// 关闭串口
        /// </summary>
        public void close()
        {
            try
            {
                iswaitingforresponse = false;
                if (serialport != null && serialport.isopen)
                {
                    serialport.close();
                    console.writeline("串口已关闭");
                }
            }
            catch (exception ex)
            {
                console.writeline($"关闭串口异常: {ex.message}");
            }
        }

        public static string[] getavailableports()
        {
            return serialport.getportnames();
        }
    }
}

namespace appflexserialport
{
    internal class program
    {
        static void main(string[] args)
        {
            flexibleserialport comm = new flexibleserialport();
            try
            {
                if (comm.initializeport("com1", 9600))
                {
                    byte[] querycommand = { 0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x84, 0x0a };
                    console.writeline("=== 方案1: 基于数据间隔判断 ===");
                    byte[] response1 = comm.sendquerywithgaptimeout(querycommand, 150, 3000);
                    thread.sleep(1000);
                    console.writeline("\n=== 方案2: 基于结束符判断 ===");
                    byte[] endmarker = { 0x0d, 0x0a }; // cr lf
                    byte[] response2 = comm.sendquerywithendmarker(querycommand, endmarker);
                    thread.sleep(1000);
                    console.writeline("\n=== 方案3: 基于协议帧结构判断 ===");
                    byte[] response3 = comm.sendquerywithframeprotocol(querycommand, 0x01, 2, 1);
                    thread.sleep(1000);
                    console.writeline("\n=== 方案4: 组合策略 ===");
                    byte[] response4 = comm.sendquerywithcombinedstrategy(
                        querycommand,
                        gaptimeoutms: 100,           // 数据间隔100ms
                        endmarker: new byte[] { 0x0a }, // 或者以lf结尾
                        maxlength: 50,               // 或者最多50字节
                        maxwaitms: 3000              // 最多等待3秒
                    );
                }
                console.writeline("按任意键退出...");
                console.readkey();
            }
            catch (exception ex)
            {
                console.writeline($"程序异常: {ex.message}");
            }
            finally
            {
                comm.close();
            }
        }
    }
}

结果如下：

性能优化与实践

关键参数调优

// ✅ 推荐配置
int gaptimeoutms = 100;    // 100-200ms适合大多数设备
int maxwaitms = 3000;      // 总超时3秒，避免程序卡死
thread.sleep(10);          // 轮询间隔10ms，平衡cpu占用和响应速度

线程安全保障

private readonly object bufferlock = new object();
// 所有缓冲区操作都要加锁
lock (bufferlock)
{
    receivedbuffer.clear();
    receivedbuffer.addrange(buffer);
    // ... 其他缓冲区操作
}

常见提醒

1、忘记清空缓冲区：每次查询前必须 receivedbuffer.clear()

2、超时时间设置不当：间隔超时太短会截断数据，太长会影响响应速度

3、线程安全问题：datareceived 事件在不同线程中执行，必须加锁保护

4、资源释放：程序结束前记得调用 close() 方法

适用场景对比

方案	适用场景	优点	缺点
间隔超时	通用场景	简单可靠	需要调试最佳间隔时间
结束符判断	文本协议	精确判断	需要明确的结束符
帧结构判断	二进制协议	最精确	需要了解协议细节
组合策略	复杂场景	最灵活	代码稍复杂