C# Socket 数据接收防丢包：三种核心实现方案解析

原始方案的数据丢失隐患

在早期的 Socket 实现中，往往采用一次性接收固定长度字节数组的方式。以下是常见的标准做法：

int recv;
IPEndPoint ipEnd = new IPEndPoint(IPAddress.Any, 8080);
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(ipEnd);
socket.Listen(10);
while (true)
{
    byte[] data = new byte[1024];
    Socket clientSocket = socket.Accept();
    // 仅调用一次 Receive，若发送方分多次发送，此处极易造成数据截断
    recv = clientSocket.Receive(data);
    if (recv == 0) break;
    string stringData = BitConverter.ToString(data, 0, recv).ToLower();
    // ... 处理数据
}

虽然该段代码结构简单，但在实际高并发或高频次通信场景（如每隔十秒上报一次的金属门传感器）中，暴露出明显缺陷：Receive 方法是阻塞式的，且单次调用可能无法读满整个缓冲区。如果上游设备发送速度大于本端处理速度，或者网络抖动导致分包，单次 Receive 极易造成后续数据滞留甚至连接假死。测试发现，使用上述方式接收传感器数据时，经常出现约 60 秒才收到一组完整数据的延迟现象。

方案一：利用 NetworkStream.Read 循环读取

NetworkStream 是封装了 Socket 的高层级流对象，其 Read 方法能更好地处理底层缓冲区的填充状态。此方案的核心在于建立一个独立的后台线程，在该线程内部通过 while ((count = stream.Read(...)) != 0) 循环持续读取，直到流关闭（返回 0）或发生异常。

// 1. 初始化 TcpListener
var serverIPEndPoint = new IPEndPoint(IPAddress.Parse("192.168.1.99"), 8234);
TcpListener tcpListener = new TcpListener(serverIPEndPoint);
tcpListener.Start();

// 2. 接受客户端连接
TcpClient tcpClient = tcpListener.AcceptTcpClient();
NetworkStream stream = tcpClient.GetStream();

// 3. 在新线程中执行稳定的接收逻辑
private void ReceiveMsg()
{
    byte[] buffer = new byte[1024]; 
    int count = 0;
    try
    {
        // 循环读取，直到返回 0 (断开) 或发生错误
        while ((count = stream.Read(buffer, 0, buffer.Length)) != 0)
        {
            // 将读取到的字节转换为十六进制字符串显示
            string stringData = "0x" + BitConverter.ToString(buffer, 0, count).Replace("-", " 0x").ToLower();
            
            // 跨线程更新 UI 控件
            this.Invoke((EventHandler)delegate
            {
                richTextBox1.Text += DateTime.Now.ToString("yy-MM-dd hh:mm:ss -*- ") + stringData + "\n";
            });
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message); // 记录断开或错误日志
    }
}

该模式配合背景线程使用，能有效避免主界面卡顿，同时 Read 方法内部的缓冲机制大幅降低了丢包概率。

方案二：Accept 后开启专属线程处理单连接

对于需要处理多个并发客户端的场景，应在 Listen 循环中接受每一个连接，并为每个连接的 Socket 创建独立的处理线程。这种方式隔离了不同客户端的通信状态，防止一个客户端的阻塞影响其他客户端。

步骤如下：

1. 创建监听套接字并绑定端口。
2. 启动后台监听线程，持续调用 Accept。
3. 一旦 Accept 成功，立即为当前的 clientSocket 启动一个新的处理线程（Received）。

void Listen(object o)
{
    try
    {
        Socket socketWatch = o as Socket;
        while (true)
        {
            // 等待并接受新连接
            socketSend = socketWatch.Accept();
            
            // 为每个客户端开启专用接收线程
            Thread r_thread = new Thread(Received);
            r_thread.IsBackground = true;
            r_thread.Start(socketSend);
        }
    }
    catch { }
}

void Received(object o)
{
    try
    {
        Socket socketSend = o as Socket;
        byte[] buffer = new byte[1024 * 1024 * 3]; // 根据需求调整缓冲区大小
        while (true)
        {
            // 实际接收到的有效字节数
            int len = socketSend.Receive(buffer);
            if (len == 0)
            {
                break; // 连接已关闭
            }
            string stringData = BitConverter.ToString(buffer, 0, len).Replace("-", " 0x").ToLower();
            
            // 同步更新 UI
            this.Invoke((EventHandler)delegate
            {
                richTextBox1.Text += DateTime.Now.ToString("yy-MM-dd hh:mm:ss -*- ") + stringData + "\n";
            });
        }
    }
    catch { }
}

方案三：结合 Task 与 Stopwatch 的性能监控版

如果需要进一步利用 .NET 的现代特性并结合性能监控，可以使用 Task.Run 替代传统的 Thread 构造器，并在接收循环中加入计时统计，以便分析网络延迟。这种方式特别适用于调试“接收慢”的问题。

// 在服务端监听循环中处理 Accept
Socket clientSocket = socket.Accept();
Task.Run(() =>
{
    Stopwatch sw = new Stopwatch();
    while (true)
    {
        sw.Restart(); // 重置计时器
        byte[] data = new byte[50];
        // 精确指定起始偏移和读取数量
        int recv = clientSocket.Receive(data, 0, data.Length, SocketFlags.None);
        
        string stringData = BitConverter.ToString(data, 0, recv).Replace("-", " 0x").ToLower();
        
        this.Invoke((EventHandler)delegate
        {
            richTextBox1.Text += DateTime.Now.ToString("yy-MM-dd hh:mm:ss -*- ") + stringData + "\n";
        });
        
        sw.Stop();
        // 打印耗时毫秒数，排查是否在处理层产生了延迟
        long times = sw.ElapsedMilliseconds;
        this.Invoke((EventHandler)delegate
        {
            richTextBox1.Text += $"执行查询总共使用了{times}毫秒\n";
        });
    }
});

在实际应用中，针对金属门等特定硬件协议，若存在数据包较小但频率低的情况，方案一的循环流读取最为稳健；而涉及大量并发物联网接入时，方案二的线程池/独立线程隔离架构更具优势。

总结

以上分析了 C# Socket 数据接收中常见的丢包原因及三种主流修复手段。从原生流的循环读取到多线程的并发管理，合理选择接收策略是构建稳定网络服务的关键。关于 C# 更高级的网络编程技巧，更多关于 Socket 状态管理与心跳检测的资料请关注本站其它相关文章！