C#Tcp中分包粘包问题以及UDP简单的介绍

TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。由于TCP是基于字节流的，它不会保留消息边界，这可能导致所谓的“粘包”或“分包”问题。

粘包问题：

当发送方向接收方连续发送多个消息时，这些消息可能会被接收方一次接收，导致多个消息“粘”在一起，接收方无法直接区分消息边界。

分包问题：

与粘包相反，一个较大的消息可能被TCP拆分成多个小的数据包发送，接收方需要在接收到所有数据包后才能重组成原始消息。

解决方案：

1. 固定长度消息：每个消息都按照固定长度发送，接收方按照这个长度来读取和解析消息。

2. 消息长度前缀：在每个消息的开始添加一个表示消息长度的字段，接收方首先读取这个长度字段，然后根据这个长度来读取剩余的数据。

3. 特殊分隔符：使用特定的字节序列作为消息的分隔符，例如HTTP协议中的 \r\n\r\n。接收方在数据流中寻找这个分隔符来确定消息边界。

4. 消息终止符：使用特定的字节作为消息的结束标志，接收方在数据流中寻找这个终止符来确定消息边界。

5. 心跳机制：定期发送心跳包，心跳包可以作为消息边界的标识，也可以用于检测连接状态。

6. 消息队列：在接收方维护一个消息队列，将接收到的数据暂存，当检测到一个完整的消息时，从队列中提取并处理。

7. 应用层协议：定义应用层协议，明确消息的开始和结束，以及如何处理消息边界。

8. 使用消息缓冲区：在接收方使用缓冲区暂存接收到的数据，当缓冲区中的数据量达到一个消息的长度时，进行处理。

Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                server.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9009));
                server.Listen();
                Task.Run(() =>
                {
                    Socket c = server.Accept();
                    List<byte> respBytes = new List<byte>();
                    while (true)
                    {
                        byte[] data = new byte[1];
                        c.Receive(data);// 接收数据字节长度
                        short len=BitConverter.ToInt16(data,0);
                        data = new byte[len];
                        c.Receive(data);// 接收实际数据
                        Console.WriteLine(Encoding.UTF8.GetString(data));
                    }
                });
                Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9009));
​
                for (int i = 0; i < 10; i++)
                {
                    // 发送端
                    //Thread.Sleep(1000);
                    string msg = "Hello";
                    byte[] data = Encoding.UTF8.GetBytes(msg);
​
                    List<byte> bytes = new List<byte>();
                    // 包头
                    short len = (short)data.Length;// 两个字节
                    bytes.AddRange(BitConverter.GetBytes(len));// 两字节长度
                    bytes.AddRange(data);// 数据有效字节
​
                    client.Send(bytes.ToArray());
                }
                Console.WriteLine("发送完成");

发送方在发送实际数据之前，先发送一个表示数据长度的短整数值，接收方首先读取这个长度信息，然后根据这个长度来读取后续的数据。这种方法可以有效地解决TCP的粘包/分包问题。

UDP

在C#中，使用UDP（用户数据报协议）通信可以通过 System.Net.Sockets 命名空间中的 UdpClient 类来实现。UDP是一种无连接的协议，它允许应用程序发送和接收数据报，但不像TCP那样保证数据的顺序、完整性和可靠性。

以下是使用C#中的 UdpClient 类进行UDP通信的基本步骤：

1. 创建 UdpClient 实例

你可以指定一个本地端口来监听传入的数据报，或者不指定端口，让系统自动选择一个可用端口。

​

UdpClient udpClient = new UdpClient(port); // 可选端口号，不指定则为0

2. 接收数据

使用 Receive 方法接收数据报。这个方法是阻塞的，直到一个数据报被接收。

​

UdpReceiveResult result = udpClient.Receive(ref remoteEndPoint);
byte[] receivedData = result.Buffer;

3. 发送数据

使用 Send 方法发送数据报。你需要指定远程端点（IP地址和端口）和要发送的数据。

​

UdpClient udpClient = new UdpClient();
IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9009);
string message = "Hello UDP!";
byte[] data = Encoding.UTF8.GetBytes(message);
int bytesSent = udpClient.Send(data, data.Length, remoteEndPoint);

4. 异步接收和发送

UdpClient 也支持异步方法，如 ReceiveAsync 和 SendAsync，它们允许在等待网络操作完成时不阻塞调用线程。

​

// 异步接收
udpClient.BeginReceive(new AsyncCallback(ReceiveCallback), udpClient);
​
// 异步发送
udpClient.BeginSend(data, data.Length, remoteEndPoint, null, null);

5. 处理接收的数据

当使用异步接收时，你需要定义一个回调方法来处理接收到的数据。

​

private static void ReceiveCallback(IAsyncResult ar)
{
    UdpClient udpClient = (UdpClient)ar.AsyncState;
    IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
    byte[] receivedData = udpClient.EndReceive(ar, ref remoteEndPoint);
    string receivedText = Encoding.UTF8.GetString(receivedData);
    Console.WriteLine($"Received: {receivedText}");
}

6. 关闭 UdpClient

完成通信后，应该关闭 UdpClient 来释放资源。

udpClient.Close();

示例：简单的UDP服务器和客户端

UDP服务器：

using System;
using System.Net;
using System.Net.Sockets;
​
class UdpServer
{
    static void Main()
    {
        int port = 9009;
        UdpClient server = new UdpClient(port);
        Console.WriteLine("UDP Server started. Listening on port " + port);
​
        while (true)
        {
            UdpReceiveResult result = server.Receive(ref remoteEndPoint);
            byte[] receivedData = result.Buffer;
            Console.WriteLine("Received data: " + BitConverter.ToString(receivedData));
        }
    }
}

UDP客户端：

using System;
using System.Net;
using System.Text;
​
class UdpClient
{
    static void Main()
    {
        string serverIp = "127.0.0.1";
        int port = 9009;
        string message = "Hello UDP Server!";
        UdpClient client = new UdpClient();
​
        byte[] data = Encoding.UTF8.GetBytes(message);
        IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Parse(serverIp), port);
        client.Send(data, data.Length, serverEndPoint);
​
        Console.WriteLine("Message sent to server.");
    }
}

UDP通信的关键在于它简单且快速，但开发者需要自行处理数据的顺序、完整性和重传等问题。