C# Socket.Receive 消息长度

Question

我目前正在开发一个 C# Socket 服务器，它可以接受来自多个客户端计算机的多个连接。服务器的目标是允许客户端“订阅”和“取消订阅”服务器事件。

到目前为止，我已经在这里仔细查看了： http://msdn.microsoft.com/en-us/library/5w7b7x5f(v=VS.100).aspx 和 http://msdn.microsoft.com/en-us/library/fx6588te.aspx 寻求想法。

我发送的所有消息都是加密的，因此我获取要发送的字符串消息，将其转换为 byte[] 数组，然后在将消息长度添加到数据之前加密数据并通过连接发送出去。

令我印象深刻的一件事是：在接收端，当只收到一半消息时，Socket.EndReceive()（或相关的回调）可能会返回。有没有一种简单的方法可以确保每条消息都被“完整”接收并且一次只能收到一条消息？

编辑： 例如，我认为 .NET / Windows 套接字不会“包装”消息以确保在一次 Socket.Receive() 调用中收到使用 Socket.Send() 发送的单个消息？或者确实如此？

到目前为止我的实现：

private void StartListening()
{
    IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
    IPEndPoint localEP = new IPEndPoint(ipHostInfo.AddressList[0], Constants.PortNumber);

    Socket listener = new Socket(localEP.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
    listener.Bind(localEP);
    listener.Listen(10);

    while (true)
    {
        // Reset the event.
        this.listenAllDone.Reset();

        // Begin waiting for a connection
        listener.BeginAccept(new AsyncCallback(this.AcceptCallback), listener);

        // Wait for the event.
        this.listenAllDone.WaitOne();
    }
}

private void AcceptCallback(IAsyncResult ar)
{
    // Get the socket that handles the client request.
    Socket listener = (Socket) ar.AsyncState;
    Socket handler = listener.EndAccept(ar);

    // Signal the main thread to continue.
    this.listenAllDone.Set();

    // Accept the incoming connection and save a reference to the new Socket in the client data.
    CClient client = new CClient();
    client.Socket = handler;

    lock (this.clientList)
    {
        this.clientList.Add(client);
    }

    while (true)
    {
        this.readAllDone.Reset();

        // Begin waiting on data from the client.
        handler.BeginReceive(client.DataBuffer, 0, client.DataBuffer.Length, 0, new AsyncCallback(this.ReadCallback), client);

        this.readAllDone.WaitOne();
    }
}

private void ReadCallback(IAsyncResult asyn)
{
    CClient theClient = (CClient)asyn.AsyncState;

    // End the receive and get the number of bytes read.
    int iRx = theClient.Socket.EndReceive(asyn);
    if (iRx != 0)
    {
        // Data was read from the socket.
        // So save the data 
        byte[] recievedMsg = new byte[iRx];
        Array.Copy(theClient.DataBuffer, recievedMsg, iRx);

        this.readAllDone.Set();

        // Decode the message recieved and act accordingly.
        theClient.DecodeAndProcessMessage(recievedMsg);

        // Go back to waiting for data.
        this.WaitForData(theClient);
    }         
}

Answer 1

是的，您可能每次只接收到部分消息，而且情况可能更糟，在传输过程中仅发送部分消息。通常您可以在网络状况不佳或网络负载过重的情况下看到这一点。

需要明确的是，在网络级别 TCP 保证按指定顺序传输您的数据，但不保证部分数据与您发送的数据相同。该软件的原因有很多（例如，查看 Nagle 算法）、硬件（跟踪中的不同路由器），操作系统实现，因此通常您不应该假设数据的哪一部分已经传输或接收。

抱歉，介绍很长，以下是一些建议：

1. 尝试为高性能套接字服务器使用相关的“新”API，此处示例.NET v4.0 的网络示例

2. 不要假设您始终发送完整数据包。 Socket.EndSend() 返回实际计划发送的字节数，它在网络负载较重的情况下甚至可以是 1-2 个字节。因此，您必须在需要时重新发送缓冲区的其余部分。

   MSDN 上有警告：

   <块引用>

   无法保证数据
   您发送的内容将出现在网络上
   立即地。增加网络
   效率，底层系统可能
   延迟传输直到显着
   收集输出数据量。
   圆满完成了
   BeginSend方法意味着
   底层系统有空间
   缓冲网络发送的数据。

3. 不要假设您总是收到完整的数据包。将接收到的数据加入某种缓冲区中，并在有足够数据时对其进行分析。

4. 通常，对于二进制协议，我添加字段来指示传入的数据量、具有消息类型的字段（或者您可以为每个消息类型使用固定长度（通常不好，例如版本控制问题））、版本字段（如果适用）并将 CRC 字段添加到消息末尾。

5. 它并不是真的需要阅读，有点旧并且直接适用于 Winsock，但也许值得研究：Winsock 程序员常见问题解答

6. 查看ProtocolBuffers，值得学习：http://code.google .com/p/protobuf-csharp-port/，http://code. google.com/p/protobuf-net/

希望有帮助。

PS 可悲的是，您在 MSDN 上引用的示例有效地破坏了其他答案中所述的异步范例。

Answer 2

你的代码是非常错误的。这样做循环违背了异步编程的目的。异步IO用于不阻塞线程而是让它们继续做其他工作。通过这样的循环，您将阻塞线程。

void StartListening()
{
    _listener.BeginAccept(OnAccept, null);
}

void OnAccept(IAsyncResult res)
{
    var clientSocket = listener.EndAccept(res);

    //begin accepting again
    _listener.BeginAccept(OnAccept, null);

   clientSocket.BeginReceive(xxxxxx, OnRead, clientSocket);
}

void OnReceive(IAsyncResult res)
{
    var socket = (Socket)res.Asyncstate;

    var bytesRead = socket.EndReceive(res);
    socket.BeginReceive(xxxxx, OnReceive, socket);

    //handle buffer here.
}

请注意，我已删除所有错误处理以使代码更清晰。该代码不会阻塞任何线程，因此效率更高。我会将代码分为两类：服务器处理代码和客户端处理代码。它使得维护和扩展变得更加容易。

接下来要了解的是 TCP 是一种流协议。它不保证消息在一次接收中到达。因此，您必须知道消息有多大或何时结束。

第一个解决方案是为每条消息添加一个标头作为前缀，您首先解析该标头，然后继续阅读，直到获得完整的正文/消息。

第二种解决方案是在每条消息的末尾放置一些控制字符并继续读取，直到读取控制字符。请记住，如果该字符可以存在于实际消息中，则应该对该字符进行编码。

Answer 3

您需要发送固定长度的消息或在标头中包含消息的长度。尝试使用一些可以让您清楚地识别数据包开始的东西。

Answer 4

我发现了 2 个非常有用的链接：

http://vadmyst.blogspot.com/2008/03/part-2-how-to-transfer-fixed-sized-data.html

C# 异步 TCP 套接字：处理缓冲区大小和巨大传输