C＃-NetworkStream.Read-填充整个缓冲区的正确方法（否则抛出异常）

Question

The NetworkStream.Read method documentation states that it returns zero on two cases:

• "If no data is available for reading, the Read method returns 0."
• "If the remote host shuts down the connection, and all available data has been received, the Read method completes immediately and return zero bytes."

And also there is the following observation:

Check to see if the NetworkStream is readable by calling the CanRead property. If you attempt to read from a NetworkStream that is not readable, you will get an IOException.

I'm very confused about it. How do I know that I can keep reading or that I should stop trying to read?

Take the following sample method:

void Receive(byte[] buffer)
{
    int idx = 0;
    while (idx < buffer.Length)
    {
        if (input.CanRead)
        {
            int read = input.Read(buffer, idx, buffer.Length - idx);

            if (read == 0)
            {
                // ???
            }

            idx += read;
        }
        else
        {
            throw new MyLibConnectionClosedException("Cannot receive because the connection was closed");
        }
    }
}

It should fill the entire buffer or it should throw an exception (if the connection was closed or lost). What is the correct way to do that?

Answer 1

Taking an evidence based approach to establishing the facts... If you look at the source code for Stream.CopyTo , which relies on method Stream.InternalCopyTo you'll see the following code for copying one stream to another:

byte[] buffer = new byte[bufferSize];
int read;
while ((read = Read(buffer, 0, buffer.Length)) != 0)
    destination.Write(buffer, 0, read);

This makes it absolutely clear to me that 0 represents the end of stream and not that "there is nothing to read now".

Any suggestion that a return value of 0 has a second meaning is incorrect, as this would make the implementation of CopyTo incorrect.

In short, to read a stream to the end, carry on reading until Read returns 0 (or an exception is thrown).