TcpClient.GetStream（）。CopyTo（MemoryStream）是否会停止应用程序的继续？

Question

I'm trying to perform some extremely basic network operations, yet I'm having some trouble.

Originally, I was trying to use NetworkStream.Length to create a new byte[] , but it became apparent that this is not possible since NetworkStream does not support seek operations.

I then found some examples showing how to copy the NetworkStream to a MemoryStream , which allows seek operations. So far, so good.

Or is it?

Once the scope of the using statement gets hit, the application essentially stops. It's still running, doing something , but I can't really tell what. Here's the code:

    void HandleClientComm(object client)
    {
        TcpClient tcpClient = (TcpClient)client;

        //copy client stream to memory stream to allow seek operations
        MemoryStream clientStream = new MemoryStream();
        using (var clientRequestStream = tcpClient.GetStream())
        {
            clientRequestStream.CopyTo(clientStream);
        }

        //...
    }

So there's where my problem has me completely stumped. I need to copy my NetworkStream to a MemoryStream to do some processing, but this task alone is proving more difficult than it should be.

Has anybody encountered this issue before?

Answer 1

A TCP stream is often not terminated - ie the inbound stream is technically alive until the socket is broken (or at a minimum : the other end of the socket elects to close their outbound link, perhaps keeping their inbound link open to get the reply).

Now: CopyTo will want to read to the end of the stream. Of a stream that has no end . The behaviour of Read is:

• block until at least one byte is available...
• or until the stream is closed...
• or until a timeout

If timeouts aren't enabled, and the socket doesn't close ever, then: boom.

For this reason, socket code usually needs to be very careful in terms of "framing" - ie knowing how much data to read as a unit. This is often done via some form length-prefix in the data stream, ie "the next message is 27 bytes" - then you know to only try to read 27 more bytes, because reading a 28th might block you forever. In text-based protocols, this is often done using sentinel values like line-feed.