Question

首先，让我解释一下我的情况：我正在使用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);
        }
    }

Answer 1

反序列化会占用一个对象的缓冲区，并在下一个对象的开头留下缓冲区的“读指针”。

我的建议是：

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

或

当你收到回调时，连续多次调用反序列化，直到你得到一个例外。

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

希望有道理。

编辑：

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

更多：

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

每次发送之间的延迟非常大，并且在发送读取之间发生接收
纯粹的意外

从C＃中的缓冲区中检索多个对象

1 个答案: