C#如何手动清除TCP套接字缓冲区？

Question

我正在编写一个 TCP 服务器来打开一个端口并与一些仅将字符串数据作为字节数组发送的硬件通信。

环境在 Unity 中，所以我使用异步回调以避免阻塞程序。这似乎工作正常，连接有效，遇到正确的数据，我可以向硬件发送消息，但套接字缓冲区永远不会清除。当我执行Socket.EndReceive(ar) 时，数据只会堆积起来，不会清空。

异步循环如何工作？我不明白为什么这段代码没有完成循环并清除缓冲区。我花了很多时间试图理解这个过程，但无法弄清楚为什么这段代码不应该工作。

    protected TcpListener ListenServer;
    protected Socket SimNetSocket;
    protected byte[] ReadBuffer = new byte[1024];
    protected string MessageBuffer;

[....] [....]

    public void BeginReceive()
    {
        SimNetSocket.BeginReceive(ReadBuffer, 0, ReadBuffer.Length, SocketFlags.None, EndReceive, null);
    }

    protected void EndReceive(IAsyncResult async)
    {
        string msg = "";

        try { msg = ByteArrayToString(ReadBuffer); }
        catch (Exception e) { Debug.LogError(e); }

        Debug.Log("RAW RECEIVE: " + msg);
        MessageBuffer += msg;
        ReadBuffer = new byte[1024];
        SimNetSocket.EndReceive(async);
        BeginReceive();
    }

MessageBuffer 是一个堆栈，稍后在处理消息的更新循环中被清除，与套接字上的ReadBuffer 复合问题无关。

同样，连接有效（代码未显示）并且通信确实有效。我可以看到数据成功地从双方传来传去，但我无法控制另一端硬件在做什么。是否需要一些实现来接收这些调用并确认缓冲区可以清除？

我实际看到的是硬件发送一条消息，然后是另一条消息，它堆积在它的最后一条消息上，一次又一次，一次又一次。不过，我正在通过上面的代码处理每条消息。所以我很困惑。

Answer 1

仅仅因为您要求读取ReadBuffer.Length 字节并不意味着实际上填充了多少字节到缓冲区。您需要保留从EndReceive 返回的int，并仅从缓冲区中读取该字节数。

public void BeginReceive()
{
    SimNetSocket.BeginReceive(ReadBuffer, 0, ReadBuffer.Length, SocketFlags.None, EndReceive, null);
}

protected void EndReceive(IAsyncResult async)
{
    string msg = "";

    int bytesRead = SimNetSocket.EndReceive(async);
    try { msg = ByteArrayToString(ReadBuffer,bytesRead); }
    catch (Exception e) { Debug.LogError(e); }

    Debug.Log("RAW RECEIVE: " + msg);
    MessageBuffer += msg;
    //ReadBuffer = new byte[1024]; //Not necessary, you can re-use the old buffer.
    BeginReceive();
}

Answer 2

您完全忽略了 EndReceive 结果，它会告诉您收到了多少字节。

像这样更改您的 EndReceive：

protected void EndReceive(IAsyncResult async)
{
    string msg = "";

    try 
    { 
        int received = SimNetSocket.EndReceive(async);
        var tmpArr = new byte[received];
        Buffer.BlockCopy(ReadBuffer, 0, tmpArr, 0, received);
        msg = ByteArrayToString(tmpArr); 
        Debug.Log("RAW RECEIVE: " + msg);
        MessageBuffer += msg;
        BeginReceive();
    }
    catch (Exception e) { Debug.LogError(e); }
}

有一些优化要做，但我无法编写它们，因为我没有完整的代码：

-修改ByteArrayToString以避免创建临时数组。

-如果执行SimNetSocket.EndReceive(async)时抛出异常，则表示连接已关闭，最好处理一下。

-请注意，您正在将接收到的数据连接到 MessageBuffer 上，您有责任在使用数据时清空此变量。

-您没有考虑读取碎片命令的可能性（至少在您提供的代码中没有）。

Answer 3

目前尚不清楚您期望发生什么。 Winsock API 中的任何内容以及该 API 上的薄 .NET 层都不会“清除”您提供的任何缓冲区。 API 所做的只是将读取操作中的字节复制到缓冲区中，或者将写入操作中的字节复制到缓冲区中。

查看您的EndReceive() 回调，您似乎确实误解了其中的某些方面。在完成读取操作之前（通过调用 EndReceive()），您正在处理 ReadBuffer 内容，并且您没有做任何事情来考虑接收到的实际字节数。如果没有一个好的 Minimal, Complete, and Verifiable code example 开头，就不可能确定您的代码应该做什么，但是您的方法的更好实现应该是这样的：

protected void EndReceive(IAsyncResult async)
{
    try
    {
        int byteCount = SimNetSocket.EndReceive(async);

        // For example (you didn't share ByteArrayToString(), so it's not clear
        // what encoding you're using, or if you're even processing the bytes
        // correctly. Feel free to modify as needed...just make sure you take
        // into account the byteCount value!
        string msg = Encoding.ASCII.GetString(ReadBuffer, 0, byteCount);

        Debug.Log("RAW RECEIVE: " + msg);
        MessageBuffer += msg;

        // There is no need to allocate a new buffer. Just reuse the one you had
        BeginReceive();
    }
    catch (IOException e)
    {
        // Don't catch all exceptions. Only exceptions that should be expected
        // here would be IOException. Other unexpected exceptions should be left
        // unhandled
        Debug.LogError(e);
        // You should close the socket here. Don't try to use that connection again
    }

}

请注意，您实际上可以处理 ASCII 以外的编码，而不必担心部分读取。为此，您必须跟踪从一个读取操作到下一个读取操作的字符解码状态。最简单的方法是使用 Decoder 对象，它有一个内部缓冲区，可以保存部分字符，直到您执行下一次解码操作。

Answer 4

我使用它来刷新（清除）Windows 和 C# 中的接收缓冲区（在我的情况下最大 2KB）：

    public void FlushReceiveBuffer()
    {
        byte[] info = new byte[2];
        byte[] outval = new byte[2000];
        try
        {
            mySock.IOControl(IOControlCode.DataToRead, info, outval);
            uint bytesAvailable = BitConverter.ToUInt32(outval, 0);
            if (bytesAvailable != 0 && bytesAvailable < 2000)
            {
                int len = mySock.Receive(outval); //Flush buffer
            }
        }
        catch
        {
            //Ignore errors
            return;
        }
    }