c# - TcpListener从C#中的套接字读取数据的问题

Question

我在使用C#中的BeginReceive/BeginSend读取从TcpClient发送到TcpListener的大型消息时遇到麻烦。

我试图在邮件中附加一个四字节长的 header ，但有时我不会将它作为第一个引起问题的数据包接收。

例如，我发送了一个序列化对象，该对象包含值[204、22、0、0]作为BeginSend中字节数组的前四个字节。我在BeginReceive上在服务器上收到的是[17，0，0，0]。发送简单的字符串时，我已经检查了Wireshark，消息正在通过中，但是我的代码有问题。另一个示例是，当我发送“A b c d e f g h i j k l m n o p q r s t v v x y z 1 2 3 4 5 6 7 8 9 0”以测试我不断收到“p q r ... 8 9 0”时。

我认为，如果数据包接收困惑或丢失，TCP将处理丢失的数据包的重新提交和/或在发送之前对它们重新排序。这意味着我的前四个字节应始终在 header 中包含我的消息大小。但是，看看上面的例子，情况并非如此，或者是这样，我的代码被弄乱了。

在下面的代码之后，我只是看它是否正在发送特定的命令或对象类型，然后根据收到的内容进行响应。

我已经具备了核心功能，可以更好地理解我可以开始重构的问题，但这确实让我停滞不前。

数天来，我一直在想办法解决这个问题，但我的头一直撞在墙上。我已经阅读了几篇有关类似问题的文章和问题，但是我还没有找到一种将建议的修复程序应用于此特定实例的方法。

在此先感谢您的协助。

以下代码中的YahtzeeClient只是具有playerinformation信息的TcpClient的包装。

    private void ReceiveMessageCallback(IAsyncResult AR)
    {
        byte[] response = new byte[0];
        byte[] header = new byte[4];
        YahtzeeClient c = (YahtzeeClient)AR.AsyncState;
        try
        {
            // If the client is connected
            if (c.ClientSocket.Client.Connected)
            {
                int received = c.ClientSocket.Client.EndReceive(AR);

                // If we didn't receive a message or a message has finished sending
                // reset the messageSize to zero to prepare for the next message.
                if (received == 0)
                {
                    messageSize = 0;

                    // Do we need to do anything else here to prepare for a new message?
                    // Clean up buffers?
                }
                else
                {
                    // Temporary buffer to trim any blanks from the message received.
                    byte[] tempBuff;

                    // Hacky way to track if this is the first message in a series of messages.
                    // If messageSize is currently set to 0 then get the new message size.
                    if (messageSize == 0)
                    {
                        tempBuff = new byte[received - 4];

                        // This will store the body of the message on the *first run only*.
                        byte[] body = new byte[received - 4];

                        // Only copy the first four bytes to get the length of the message.
                        Array.Copy(_buffer, header, 4);

                        // Copy the remainder of the message into the body.
                        Array.Copy(_buffer, 4, body, 0, received - 4);

                        messageSize = BitConverter.ToInt32(header, 0);

                        Array.Copy(body, tempBuff, body.Length);
                    }
                    else
                    {
                        // Since this isn't the first message containing the header packet
                        // we want to copy the entire contents of the byte array.
                        tempBuff = new byte[received];
                        Array.Copy(_buffer, tempBuff, received);
                    }

                    // MessageReceived will store the entire contents of all messages in this tranmission.
                    // If it is an new message then initialize the array.
                    if (messageReceived == null || messageReceived.Length == 0)
                    {
                        Array.Resize(ref messageReceived, 0);
                    }

                    // Store the message in the array.
                    messageReceived = AppendToArray(tempBuff, messageReceived);

                    if (messageReceived.Length < messageSize)
                    {
                        // Begin receiving again to get the rest of the packets for this stream.
                        c.ClientSocket.Client.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceiveMessageCallback, c);
                        // Break out of the function.  We do not want to proceed until we have a complete transmission.
                        return;
                    }

                    // Send it to the console
                    string message = Encoding.UTF8.GetString(messageReceived);

**标记为已解决。解决方案是将消息包装在消息头和消息终止符的末尾，然后修改代码以查找这些指示符。

使用套接字的原因是由于对项目的限制，使得无法选择Web服务。

Answer 1

您遇到问题是因为您不知道第一个消息的大小，有时会越来越多，有时会越来越少，有时您会得到缓存中剩余的一些信息...

一个简单的解决方案是始终在实际消息之前发送消息大小，例如:

[MYHEADER] [32位整数] [消息内容]

让我们假设MYHEADER是ASCII，只是一个虚拟标识符，在这种情况下，我将:

1:尝试接收12个字节以捕获整个 header (MYHEADER + 32Bit Integer)，在您执行任何操作之前不要执行任何操作。此后，如果 header 标识符不是MYHEADER，则我认为该消息已损坏，并且在连接中将出现诸如复位的情况。

2:确认报头正常后，我将检查消息大小的32位整数并分配必要的缓冲区。 (您可能想在这里限制内存使用，最大为6Mb，如果您的消息超出此范围，请在32位整数之后添加一个索引以指定消息部分...)

3:尝试接收，直到标题中指定的邮件大小为止。