How does the TcpClient write make sure the data is delivered to the server?

@CodeCaster is correct and highlights the .NET documentation defining the behavior of .Write (). Here are some complete test codes to prove that he is right, and the other answers that say "TCP guarantees message delivery" are unequivocally wrong:

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace TestEvents
{
    class Program
    {
        static void Main(string[] args)
        {
            // Server: Start listening for incoming connections
            const int PORT = 4411;
            var listener = new TcpListener(IPAddress.Any, PORT);
            listener.Start();

            // Client: Connect to listener
            var client = new TcpClient();
            client.Connect(IPAddress.Loopback, PORT);

            // Server: Accept incoming connection from client
            TcpClient server = listener.AcceptTcpClient();

            // Server: Send a message back to client to prove we're connected
            const string msg = "We are now connected";
            NetworkStream serverStream = server.GetStream();
            serverStream.Write(ASCIIEncoding.ASCII.GetBytes(msg), 0, msg.Length);

            // Client: Receive message from server to prove we're connected
            var buffer = new byte[1024];
            NetworkStream clientStream = client.GetStream();
            int n = clientStream.Read(buffer, 0, buffer.Length);
            Console.WriteLine("Received message from server: " + ASCIIEncoding.ASCII.GetString(buffer, 0, n));

            // Client: Close connection and wait a little to make sure we won't ACK any more of server messages
            Console.WriteLine("Client is closing connection");
            clientStream.Dispose();
            client.Close();
            Thread.Sleep(5000);
            Console.WriteLine("Client has closed his end of the connection");

            // Server: Send a message to client that client could not possibly receive
            serverStream.Write(ASCIIEncoding.ASCII.GetBytes(msg), 0, msg.Length);
            Console.WriteLine(".Write has completed on the server side even though the client will never receive the message.  server.Client.Connected=" + server.Client.Connected);

            // Let the user see the results
            Console.ReadKey();
        }
    }
}

      

        
        
        
      

    

It should be noted that execution is usually through the program, and serverStream does not indicate that the second .Write was not successful. This is despite the fact that there is no way the second message can be delivered to its recipient. For a more detailed look at what's going on, you can replace IPAddress.Loopback with a longer route to your computer (for example, have router routing port 4411 to your development computer and use the look and feel of your modem's IP address) and monitor this port in Virešarka. This is what the result looks like:

Port 51380 is a randomly selected port that represents the client TcpClient in the code above. There are two packages because this setup is using NAT on my router. So the first SYN packet is my computer -> my external IP. The second SYN packet is my router -> my computer. The first PSH packet is the first Stream.Write server. The second PSH package is the second Stream.Write server.

It could be argued that the client is doing an ACK at the TCP layer with the RST packet, but 1) this is not relevant to using the TcpClient as it means the TcpClient is ACKing with a closed connection and 2) considers what happens when the connection is completely disconnected in the next paragraph.

If I comment out the lines that delete the thread and close the client, and instead disconnect from my wireless network during Thread.Sleep, the console prints the same output and I get this from Wireshark:

Basically, .Write returns without exception even if the PSH packet hasn't even been sent, let alone received an ACK.

If I repeat the above process but disable my wireless card instead of just disconnecting, THEN the second .Write throws an exception.

Bottom line, @CodeCaster's answer is unambiguously correct at all levels and more than one of the other answers here is wrong.