Question

我正在编写客户端/服务器应用程序。当使用环回地址进行连接时似乎运行良好，但是当通过局域网或互联网连接时，我遇到了一个我无法弄清楚的非常奇怪的问题。

服务器和客户端之间发送的所有数据都包含在名为“DataPacket”的类中。然后将该类序列化为二进制，以便可以使用套接字发送它。

在发送数据包之前，附加一个4字节的头，其中包含数据包的字节长度，以便接收者知道在反序列化之前需要多少字节。问题是，在某些时候，接收器认为它正在等待比标头中实际发送的数据更多的数据。有时这个数字是数百万字节，这导致了严重的问题。

这是数据的发送方式：

public override void Send(DataPacket packet)
{
    byte[] content = packet.Serialize();
    byte[] header = BitConverter.GetBytes(content.Length);

    List<Byte> bytes = new List<Byte>();
    bytes.AddRange(header);
    bytes.AddRange(content);

    if (socket.Connected)
    {
        socket.BeginSend(bytes.ToArray(), 0, bytes.Count, SocketFlags.None, OnSendPacket, socket);
    }
}

在服务器端，为每个客户端分配一个StateObject - 这是一个类，用于保存用户套接字，缓冲区以及到目前为止收到的任何不完整的数据。

这是StateObject类的外观：

public class StateObject
{
    public const int HeaderSize = 4;
    public const int BufferSize = 8192;

    public Socket Socket { get; private set; }
    public List<Byte> Data { get; set; }
    public byte[] Header { get; set; }
    public byte[] Buffer { get; set; }

    public StateObject(Socket sock)
    {
        Socket = sock;
        Data = new List<Byte>();
        Header = new byte[HeaderSize];
        Buffer = new byte[BufferSize];
    }
}

这是StateObject类的使用方式：

private void OnClientConnect(IAsyncResult result)
{
    Socket serverSock = (Socket)result.AsyncState;
    Socket clientSock = serverSock.EndAccept(result);

    StateObject so = new StateObject(clientSock);
    so.Socket.BeginReceive(so.Buffer, 0, StateObject.BufferSize, SocketFlags.None, OnReceiveData, so);
}

从客户端收到一些数据时，会调用EndReceive。如果StateObject.Data为空，则假定这是新数据包的第一部分，因此检查标头。如果收到的字节数小于标题中显示的大小，那么我再次调用BeginReceive，重新使用相同的StateObject。

以下是OnReceiveData的代码：

private void OnReceiveData(IAsyncResult result)
{
    StateObject state = (StateObject)result.AsyncState;

    int bytes = state.Socket.EndReceive(result);
    if (bytes > 0)
    {
        state.ProcessReceivedData(bytes);

        if (state.CheckDataOutstanding())
        {
            //Wait until all data has been received.
            WaitForData(state);
        }
        else
        {
            ThreadPool.QueueUserWorkItem(OnPacketReceived, state);

            //Continue receiving data from client.
            WaitForData(new StateObject(state.Socket));
        }
    }
}

从上面可以看出，首先我调用state.ProcessReceivedData（） - 这是我从数据中分离标头，然后从缓冲区移动数据的地方：

public void ProcessReceivedData(int byteCount)
{
    int offset = 0;

    if (Data.Count == 0)
    {
        //This is the first part of the message so get the header.
        System.Buffer.BlockCopy(Buffer, 0, Header, 0, HeaderSize);
        offset = HeaderSize;
    }

    byte[] temp = new byte[byteCount - offset];
    System.Buffer.BlockCopy(Buffer, offset, temp, 0, temp.Length);
    Data.AddRange(temp);
}

然后我调用CheckDataOutstanding（）来比较接收的字节数和标头中的大小。如果这些匹配，那么我可以安全地反序列化数据：

public bool CheckDataOutstanding()
{
    int totalBytes = BitConverter.ToInt32(Header, 0);
    int receivedBytes = Data.Count;
    int outstanding = totalBytes - receivedBytes;

    return outstanding > 0;
}

问题在于，标题中的值最终会以与发送的值不同的值结束。这似乎是随机发生的，有时是在服务器上，有时是在客户端上。由于在整个网络中调试服务器和客户端的随机性和一般难度，我发现几乎不可能弄清楚这一点。

我在这里缺少一些明显或愚蠢的东西吗？

Answer 1

如果只获得标题的部分，会发生什么？也就是说，假设您在第一次读取时有三个字节而不是四个或更多？您的ProcessReceivedData函数需要考虑到这一点，并且在您至少有四个字节之前不要尝试提取标题大小。

通过套接字发送数据时计算字节长度的问题

1 个答案: