Question

我无法在C＃中使用BeginReceive / BeginSend从TcpClient读取发送到TcpListener的大型消息。

我试图在我的邮件中附加一个四字节长的标题，但有时我不会收到它作为导致问题的第一个数据包。

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

我认为如果数据包是无序接收或者丢弃了一个数据包，TCP会在发送之前处理丢失数据包的重新提交和/或重新排序。这意味着我的前四个字节应始终在标头中包含我的消息大小。但是，看看上面的例子，情况并非如此，或者说我的代码在某个地方搞砸了。

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

我已经掌握了核心功能，并且能够更好地理解我可以开始重构的问题，但这确实让我处于停滞状态。

我试图调试这个问题几天来一直撞墙。我已经阅读了几篇关于类似问题的文章和问题，但我还没有找到一种方法将建议的修复应用于这个特定的实例。

预先感谢您对此的帮助。

以下代码中的YahtzeeClient只是带有播放器信息的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个字节以捕获整个标题（MYHEADER + 32Bit Integer）并且除非你这样做，否则不要做任何事情。之后，如果标题标识符不是MYHEADER，那么我会认为该消息已损坏并且在连接中会有类似重置的内容。

2：在我确认标题正常后，我会检查32位整数的消息大小并分配必要的缓冲区。（您可能希望限制内存使用量，例如6Mb max，如果您的消息超出此范围，请在32位整数后添加索引以指定消息部分...）

3：尝试接收，直到标题中指定的消息大小为止。

Answer 2

您似乎不太了解TCP是没有边界的字节流这一事实。例如，如果在该读取中少于4个字节，则标题读取将失败。

接收长度前缀消息的一种非常简单的方法是使用BinaryReader：

var length = br.ReadInt32();
var data = br.ReadBytes(length);

这就是全部。熟悉所有标准BCL IO类。

通常最好不要使用套接字。使用更高级别的协议。 WCF很好。

TcpListener在c＃

2 个答案: