2

首先，让我解释一下我的情况：我正在使用 C# 开发客户端和服务器，它们使用套接字进行通信。

出于实际原因，我使用两个套接字的异步部分将二进制序列化对象从客户端传输到服务器，反之亦然。

我的问题是，当我一次发送太多对象时，接收对象“堆栈”到缓冲区中，当我尝试反序列化缓冲区内容时，它只给我一个对象。

我的问题是：如何将每个对象与缓冲区分开？

这是我的ReceiveCallback功能：

private void ReceiveMessageCallback(IAsyncResult asyncResult)
    {
        Socket socket = (Socket)asyncResult.AsyncState;
        try
        {
            int read = socket.EndReceive(asyncResult);
            if (read > 0)
            {
                Log("Reception of " + read + " Bytes");

                // Jumper is an object that I use to transport every message
                Jumper pod = Common.Serializer.DeSerialize<Jumper>(this.readbuf);

                Buffer.SetByte(this.readbuf, 0, 0);
                socket.BeginReceive(this.readbuf, 0, this.readbuf.Length, SocketFlags.None, new AsyncCallback(ReceiveMessageCallback), socket);

                //We fire an event to externalise the analyse process
                Receiver(pod, socket);
            }
        }
        catch (SocketException ex)
        {
            if (ex.SocketErrorCode == System.Net.Sockets.SocketError.ConnectionReset)
            {
                socket.Close();
                Log("Distant socket closed");
            }
            else
                Log(ex.Message);
        }
        catch (Exception ex)
        {
            Log(ex.Message);
        }
    }
4

1 回答 1

0

反序列化将消耗一个对象的缓冲区，并将在下一个对象的开头留下缓冲区的“读取指针”。

我的建议是：

  • 将数据从套接字流移动到其他（内存）缓冲区并从那里反序列化，并手动控制整个“缓冲”

或者

  • 当你收到回调时，连续调用几次反序列化，直到你得到一个异常。

第二种方法很可能会失败，因为没有人能保证你总是会一次获得整个对象，因为附加到套接字的流是一个字节序列，它可以在任何时候被破坏。

希望这有点道理。

编辑：

事实上，正确的做法是将每个“消息”（发送时的序列化对象）封装到一个数据包中，例如，您将有一个小标题告诉您数据包的长度，并且在接收时，您将读取套接字流，直到您有完整的数据包数据，然后序列化。然后是下一个数据包，以此类推。

更：

假设您在发送方以 1000 字节的速率将数据发送到套接字中。在接收端，您可能永远不会从套接字中获得 1000 x 1000 字节，事实上，您只能在两种情况下预期：

  • 每次发送之间的延迟非常大，并且在发送之间读取发生在接收方
  • 纯属意外
于 2012-06-15T15:46:51.087 回答