C# TcpClient 从流中读取或获取不完整的数据

Question

I have an exe which simulates a video stream. I connect to it and very occasionally read the expected data, but usually I get only the first 28 bytes and then 65508 bytes of zeros. Assume the video stream is working correctly.

TcpClient tcpClient = new TcpClient ();

int port = 13000;
myIP = IPAddress.Loopback.ToString();

tcpClient.Connect (myIP, port);
NetworkStream netStream = tcpClient.GetStream ();

byte[] bytes = new byte[tcpClient.ReceiveBufferSize];

netStream.Read (bytes, 0, (int)tcpClient.ReceiveBufferSize);

string dataString = Encoding.ASCII.GetString (bytes);

Console.WriteLine("\ndataString: "+dataString.Substring(0,1000));
Console.WriteLine("\nnumber of bytes read: "+bytes.Length); 

tcpClient.Close ();
// Closing the tcpClient instance does not close the network stream.
netStream.Close();

How can I make it so that I get the expected output every time?

Answer 1

TCP represents a (bi-directional) stream of data. You're supposed to keep reading from it in a loop, and parsing the data as you need them. It doesn't have a concept of messages - ten writes on one side can result in a single read on the other side just as easily as one write on one side can result in ten reads on the other side.

The contract you have with TCP is as follows:

• If there is data in the receive buffer, Read returns immediately, filling the buffer you provided with as much data as is available, up to the length of the buffer. The number of bytes read is the return value of Read .
• If there is no data in the receive buffer, Read will block until there's at least a single byte of data. Then it follows as in the first case.
• If the other sides shuts down the socket, Read will return zero.

So to get TCP working, you need a loop. How exactly you form the loop depends on what you're trying to do. If you're really working with data that is logically a stream (eg audio data), just keep reading as fast as you can and process whatever data you get as it comes in. If you need to send messages, you need to implement a message protocol. If you need a one-off message, you can just keep reading until Read returns zero.

Your case can be handled with the first approach - keep reading until the stream closes, and push the received data forward. Assuming the data is actually a UTF8 stream of text, the basic receiver would look something like this:

using (var client = new TcpClient())
{
  tcpClient.Connect(myIP, port);

  var stream = client.GetStream();
  var buffer = new byte[4096]; // Adapt the size based on what you want to do with the data
  var charBuffer = new char[4096];
  var decoder = Encoding.UTF8.GetDecoder();

  int bytesRead;
  while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
  {
    var expectedChars = decoder.GetCharCount(buffer, 0, bytesRead);
    if (charBuffer.Length < expectedChars) charBuffer = new char[expectedChars];

    var charCount = decoder.GetChars(buffer, 0, bytesRead, charBuffer, 0);
    Console.Write(new string(charBuffer, 0, charCount));
  }

  client.Close();
}

Note that this does no error handling, so don't use it as is in any production code. You would probably also want to use Async methods if you're expecting more than a few simultaneous connections. It's just to illustrate the basic way one would handle a stream of data being received over TCP.

If you want some more insight into dealing with TCP, I have a few very simple examples at https://github.com/Luaancz/Networking . I haven't found any good tutorials or code samples for C#, so if this isn't enough, you'll probably have to dig deeper into the documentation around sockets, TCP and all that.

Or just use an existing networking library, rather than trying to write your own :) TCP is still very low level.