1

What is the behaviour of the NetworkStream.Write() method, if I send data via a TcpClient's NetworkStream, and the TcpClient.SendBufferSize is smaller than the data?

The MSDN documentation for SendBufferSize says

If the network buffer is smaller than the amount of data you provide the Write method, several network send operations will be performed for every call you make to the Write method. You can achieve greater data throughput by ensuring that your network buffer is at least as large as your application buffer.

So I know that the data will be sent in multiple operations, and the receiving TCP-Stack should reassemble it into one continuous stream transparently.

But what happens exactly in my program during this time?

If there is enough space in the SendBuffer, TcpClient.GetStream().Write() will not block at all, and return immediately and so will NetworkStream.Flush().

If I set the TcpClient.SendBufferSize to a value smaller than the data, will the Write() block until

  • either the first part of the data has been received and ACKed,
  • or the TcpClient.SendTimeout has expired?

Or does it work in some other way? Does it actually wait for a TCP ACK?

Are there any other drawbacks besides higher overhead to such a smaller buffer size? Are there problems with changing the SendBufferSize on the fly?

Example:

byte[] data = new byte[20]    // 20 byte data
tcpClient.SendBufferSize= 10; // 10 byte buffer
tcpClient.SendTimeout = 1000; // 1s timeout

tcpClient.GetStream().Write(data,0,20); 
// will this block until the first 10 bytes have been full transmitted?
// does it block until a TCP ACK has been received? or something else?
// will it throw if the first 10 bytes have not been received in 1 second?
tcpClient.GetStream().Flush(); // would this make any difference?

My goal here is mainly getting a better understanding of the network internals.

Also , I was wondering if this could be abused to react more quickly to a network failure. If data is sent only infrequently, and each data packet is small enough to be transmitted at once, and there are no receipt messages in a given message protocol, it could take a long time after a network error until the next Write() is called; so a long time until an exception is thrown.

If the SentBuffer is very small, would an error be noticed more quickly, unless it happened at end of the data?

Could I abuse this to measure the time it takes for a single packet to be transmitted and ACKed?

HugoRune
  • 13,157
  • 7
  • 69
  • 144
  • Microsoft uses timers to Move data from application to Ethernet port. Mostly using the time tick events. So then entire buffer size is moved even though it is not full. The TCP datagrams have maximum size of ~1500 bytes. Larger messages are always broken into smaller datagrams. The link you provided is for Network stream and you can send tcp using sockets as well. Network stream is just a class for adding a stream layer to a tcp socket. As I said earlier stream classes in Net uses timers to empty and fill so there may be some latency depending on size of buffers causing inefficiencies. – jdweng Jun 03 '17 at 12:53

0 Answers0