C#实现Socket数据接收的三种经典方式_Asp.net

前言

在工业自动化、物联网（iot）和网络通信等领域，socket 编程是实现设备间数据交互的核心技术。c# 作为 .net 平台的主要开发语言，提供强大的网络编程支持。然而，在实际开发中，很多开发在使用 socket.receive 方法接收数据时，常常遇到数据丢失、接收延迟、性能瓶颈等问题。

本文将深入探讨 c# 中实现 socket 数据接收的三种经典方式，结合真实案例分析常见问题，并提供优化后的完整代码示例，帮助大家开发稳定、高效的网络通信系统。

问题背景

在传统的 socket 数据接收方式中，通常采用如下代码：

int recv;//定义接收数据长度变量
ipendpoint ipend = new ipendpoint(ipaddress.parse(textbox1.text), int.parse(textbox2.text));
//接收端所监听的接口,ip也可以用ipaddress.any
socket socket = new socket(addressfamily.internetwork, sockettype.stream, protocoltype.tcp);
//初始化一个socket对象
socket.bind(ipend);
//绑定套接字到一个ip地址和一个端口上(bind())；
socket.listen(10);
while (true)
{
    byte[] data = new byte[1024];//对data清零
    socket clientsocket = socket.accept(); 
    //一旦接受连接，创建一个客户端
    recv = clientsocket.receive(data);
    if (recv == 0) 
    //如果收到的数据长度小于0，则退出
        break;
    string stringdata = "0x" + bitconverter.tostring(data).replace("-", " 0x").tolower();
    
    this.invoke((eventhandler)delegate
    {
        richtextbox1.text += datetime.now.tostring("yy-mm-dd hh:mm:ss")  + stringdata + "\n";
    });
}

这种写法在简单场景下看似可行，但在处理高频、小包数据（如金属门每10秒发送一次数据）时，会出现严重的数据积压和延迟——原本应60秒接收6组数据，却可能60秒才收到一组，导致数据丢失。

根本原因在于：receive 方法被放在 accept 之后的单次调用中，未能持续监听和接收数据流。

三种高效的数据接收方式

为解决上述问题，以下介绍三种经过验证的 c# socket 数据接收方案。

方式一：基于networkstream.read的持续监听

使用 tcpclient 和 networkstream，通过 stream.read 方法实现阻塞式持续读取。

private void bgworker_dowork()
{
    var serveripendpoint = new ipendpoint(ipaddress.parse("192.168.1.99"), 8234); // 当前服务器使用的ip和端口
    tcplistener tcplistener = new tcplistener(serveripendpoint);
    tcplistener.start();
    console.writeline("服务端已启用......"); // 阻塞线程的执行，直到一个客户端连接
    tcpclient = tcplistener.accepttcpclient();
    console.writeline("已连接.");
    stream = tcpclient.getstream();          // 创建用于发送和接受数据的networkstream

    var t1 = new thread(receivemsg);
    t1.isbackground = true;
    t1.start();
}

void receivemsg()
{
    byte[] buffer = new byte[1024]; // 预设最大接受1024个字节长度，可修改
    int count = 0;
    try
    {
        while ((count = stream.read(buffer, 0, buffer.length)) != 0)
        {
            string stringdata = "0x" + bitconverter.tostring(buffer, 0, count).replace("-", " 0x").tolower();
            console.writeline($"{tcpclient.client.localendpoint.tostring()}:{datetime.now.tostring("yy-mm-dd hh:mm:ss -*- ") + stringdata + "\n"}");
            this.invoke((eventhandler)delegate
            {
                richtextbox1.text += datetime.now.tostring("yy-mm-dd hh:mm:ss -*- ") + stringdata + "\n";
            });
        }
    }
    catch(exception ex)
    {
        console.writeline(ex.message);
    }
}

优点：代码简洁，networkstream.read 自动处理流的持续读取。

适用场景：单客户端通信，如设备与上位机一对一连接。

方式二：多线程处理多个客户端连接

为每个客户端连接创建独立线程，确保接收不阻塞主线程。

private void bgworker_dowork1()
{
    int recv;
    ipendpoint ipend = new ipendpoint(ipaddress.parse(textbox1.text), int.parse(textbox2.text));
    socket socket = new socket(addressfamily.internetwork, sockettype.stream, protocoltype.tcp);
    socket.bind(ipend);
    socket.listen(10);

    thread thread = new thread(listen);
    thread.isbackground = true;
    thread.start(socket);
}

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;
        while (true)
        {
            byte[] buffer = new byte[1024 * 1024 * 3];
            int len = socketsend.receive(buffer);
            if (len == 0)
            {
                break;
            }
            string stringdata = "0x" + bitconverter.tostring(buffer, 0, len).replace("-", " 0x").tolower();
            this.invoke((eventhandler)delegate
            {
                richtextbox1.text += datetime.now.tostring("yy-mm-dd hh:mm:ss -*- ") + stringdata + "\n";
            });
        }
    }
    catch { }
}

优点：支持多客户端并发连接，接收独立，互不干扰。

适用场景：多设备接入的服务器端程序。

方式三：task + background thread 实现异步接收

结合 task.run 和后台线程，实现轻量级异步接收，避免线程资源浪费。

private void bgworker_dowork2()
{
    int recv;
    ipendpoint ipend = new ipendpoint(ipaddress.parse(textbox1.text), int.parse(textbox2.text));
    socket socket = new socket(addressfamily.internetwork, sockettype.stream, protocoltype.tcp);
    socket.bind(ipend);
    socket.listen(10);
    new thread(delegate ()
    {
        socket clientsocket = null;
        while (true)
        {
            stopwatch sw = new stopwatch();
            sw.start();

            clientsocket = socket.accept();

            task.run(() =>
            {
                while (true)
                {
                    byte[] data = new byte[50];
                    recv = clientsocket.receive(data, 0, data.length, socketflags.none);
                    string stringdata = "0x" + 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";
                    });
                }
            });
        }
    })
    { isbackground = true }.start();
}

优点：异步非阻塞，资源利用率高，适合高并发场景。

适用场景：需要高性能、低延迟的工业通信系统。