NetworkStream 从套接字缓冲区读取不应该存在的数据时出现问题。顺便说一句，我正在发送非常大的缓冲区。现在我刚刚在本地主机上进行测试。

这是我读取数据的方式，前 4 个字节包含消息的长度，然后我只读取 4096 个 block ，直到达到消息的长度。

    protected TcpClient tcpObject;
    protected NetworkStream tcpStream;

    private void HandleComm()
    {
        try
        {
            tcpStream = tcpObject.GetStream();
            byte[] totalByteAray = new byte[constIntSize];
            byte[] message = new byte[constChunkSize];
            byte[] fullMessage = new byte[0];

            //this is how many bytes long the message will be
            int totalBytes = 0;
            int currentBytes = 0;
            int chunkSize = constChunkSize;

            while (true)
            {
                //skip reading if no data is available
                //DataAvailable does not tell you when all the data has arrived
                //it just tell you if some data has arrived
                if (tcpStream.CanRead)
                {
                    totalBytes = 0;
                    currentBytes = 0;
                    message = new byte[constChunkSize];
                    chunkSize = constChunkSize;

                    //The first 4 bytes of the message will always contain the length of the message, not including
                    //the first 4 bytes. This is how you know when to stop reading.
                    tcpStream.Read(totalByteAray, 0, constIntSize);                        
                    //there are 4 bytes in a 32 bit number, so totalByteArrayContains 4 index that is a byte which is
                    //the 32 bit int that tells us how many bytes the whole message will be.
                    //now convert the totalByteArray to a 32bit int
                    totalBytes = BitConverter.ToInt32(totalByteAray, 0);
                    Console.WriteLine("reading " + totalBytes);
                    //fullMessage will contain the entire message but it has to be built message by message.                    
                    fullMessage = new byte[totalBytes];
                    //keep reading until we get all the data
                    while (currentBytes < totalBytes)
                    {

                        //when you send something over TCP it will some times get split up
                        //this is why you only read in chuncks, 4096 is a safe amount of bytes
                        //to split the data into.
                        if (totalBytes - currentBytes < constChunkSize)
                        {
                            chunkSize = totalBytes - currentBytes;
                            message = new byte[chunkSize];
                        }

                        tcpStream.Read(message, 0, chunkSize);
                        //since we know each chunk will always come in at 4096 bytes if it doesn't that means that it's the end
                        //this part cuts off the extra empty bytes                           

                        //copy the message to fullMessage starting at current bytes and ending with the bytes left
                        message.CopyTo(fullMessage, currentBytes);
                        currentBytes += chunkSize;                            
                    }

                    //message has successfully been received
                    if (totalBytes != 0)
                    {

                        if (OnRawDataReceived != null)
                        {
                            RawDataReceivedArgs args = new RawDataReceivedArgs();
                            args.Data = new byte[fullMessage.Length];
                            fullMessage.CopyTo(args.Data, 0);
                            OnRawDataReceived(this, args);
                        }

                        totalBytes = 0;
                    }
                }
            }
        }
        catch
        {
            connectionStatus = ConnectionStatus.NotConnected;
            if (OnDisConnect != null)
                OnDisConnect(this, null);
        }
    }

这是我发送数据的方式，我只获取消息的长度，然后创建一条新消息，前 4 个字节是消息的长度，其余是实际消息。

    protected void sendData(byte[] data)
    {
        //we need to know how big the data that we are sending will be
        int length = data.Length;
        System.Console.WriteLine("writing " + length);
        //convert the 32bit int to a 4 byte array
        byte[] lengthArray = BitConverter.GetBytes(length);

        //init the main byte array that will be sent over
        byte[] buffer = new byte[length + constIntSize];

        //the first 4 bytes will contain the length of the data
        lengthArray.CopyTo(buffer, 0);

        //the rest of the buffer will contain the data being sent
        data.CopyTo(buffer, constIntSize);

        //wite it to the client stream
        tcpStream.Write(buffer, 0, length + constIntSize);
        //now send it
        tcpStream.Flush();           
    }

出于某种原因，我正在读取不应该在缓冲区中的数据。这是控制台输出。

服务器------------客户端

写1024 -> 读1024

阅读 1228800 <- 写作="">

写1024 -> 读1024

阅读 1228800 <- 写作="">

读书7224842

所以当我点击一个按钮时，它会发送一个请求说我想要一个来自网络摄像头的图像，这个请求是 1024 字节。客户端读取它并发送 1228800 字节的图像。我第一次这样做时，它总是有效。第二次单击它时，客户端发回了 1228800 字节，服务器读取了正确的字节数，然后在套接字缓冲区本应为空时发现了更多字节要读取。我在套接字缓冲区中没有 7224842 字节，这正是读取的前 4 个字节所说的。

关于缓冲区为什么在其中获取额外数据的任何想法？当我发送较小的消息时，一切似乎都运行良好，但这让我发疯。

最佳答案

tcpStream.Read(totalByteAray, 0, constIntSize);
...
tcpStream.Read(message, 0, chunkSize);

这就是整个问题。这是一项要求，您检查返回到此。不能保证(并且对于基于网络的 IO，不太可能)您会立即获得整个缓冲区 - 数据包会在任何时候进入，API 会为您提供它能做的。相反，您将得到“一些”(结果 > 0 且 <= 计数)或“无”(结果=""><=>

如果你想读取恰好那么多的数据，那么写一个实用方法:

static void ReadExact(Stream stream, byte[] buffer, int offset, int count)
{
    int read;
    while(count > 0 && (read = stream.Read(buffer, offset, count)) > 0) {
        offset += read;
        count -= read;
    }
    if(count != 0) throw new EndOfStreamException();
}

关于c# - NetworkStream 正在读取不应该存在的数据，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/9459880/