Server/Client TCP/IP Sample

Question

Server/Client TCP/IP Sample

Noah Aas 1,210

The goal:
I create two C# desktop WPF applications. Two applications each.

One server
One client

The exchange should take place via TCP/IP. Messages must be transmitted in both directions. Question Answer. When an application is closed and reopened, a connection should follow automatically.
Do you have any good ideas or examples with TcpClient and TcpListener library?
I see the following challenge.
The user interface and the automatic connection. Ideally, I should be able to see in the user interface what has been sent, what has been received, and whether the connection is active.

enter image description here

Starry Night 625 Reputation points

2025-10-24T03:17:59.5933333+00:00
TcpClient and TcpListener are built on top of the System.Net.Sockets.Socket class and take care of the details of transferring data for ease of use.

1.Create a TcpClient

The TcpClient class provides TCP services at a higher level of abstraction than the Socket class. TcpClient is used to create a client connection to a remote host. Knowing how to get an IPEndPoint, let's assume you have an IPAddress to pair with your desired port number. The following example demonstrates setting up a TcpClient to connect to a time server on TCP port 13:

var ipEndPoint = new IPEndPoint(ipAddress, 13); using TcpClient client = new(); await client.ConnectAsync(ipEndPoint); await using NetworkStream stream = client.GetStream(); var buffer = new byte[1_024]; int received = await stream.ReadAsync(buffer); var message = Encoding.UTF8.GetString(buffer, 0, received); Console.WriteLine($"Message received: \"{message}\""); // Sample output: // Message received: "📅 8/22/2022 9:07:17 AM 🕛"

2.Create a TcpListener

The TcpListener type is used to monitor a TCP port for incoming requests and then create either a Socket or a TcpClient that manages the connection to the client. The Start method enables listening, and the Stop method disables listening on the port. The AcceptTcpClientAsync method accepts incoming connection requests and creates a TcpClient to handle the request, and the AcceptSocketAsync method accepts incoming connection requests and creates a Socket to handle the request.

The following example demonstrates creating a network time server using a TcpListener to monitor TCP port 13. When an incoming connection request is accepted, the time server responds with the current date and time from the host server.

var ipEndPoint = new IPEndPoint(IPAddress.Any, 13); TcpListener listener = new(ipEndPoint); try { listener.Start(); using TcpClient handler = await listener.AcceptTcpClientAsync(); await using NetworkStream stream = handler.GetStream(); var message = $"📅 {DateTime.Now} 🕛"; var dateTimeBytes = Encoding.UTF8.GetBytes(message); await stream.WriteAsync(dateTimeBytes); Console.WriteLine($"Sent message: \"{message}\""); // Sample output: // Sent message: "📅 8/22/2022 9:07:17 AM 🕛" } finally { listener.Stop(); }

For more information, you can check document:

TCP overview

Simple TCP Server and Client with TcpListener and TcpClient .

Developing a Simple Chat Tool using C# TcpClient and TcpListener

Noah Aas 1,210

First, thanks for your help!

https://github.com/iqfareez/TCP-App

I found a good example. (Not so big, good way to start up with TCP/IP) Can you help me to understand it? ** _ = ReceiveDataAsync();**

public class MyTcpClient
 {
     private TcpClient _client;

     public event EventHandler<string> MessageReceived;

     /// <summary>
     /// Connect to the TCP server
     /// </summary>
     /// <param name="ipAddress"></param>
     /// <param name="port"></param>
     public void Connect(string ipAddress, int port)
     {
         _client = new TcpClient();
         _client.Connect(ipAddress, port);

         // Start a separate task to receive data
         _ = ReceiveDataAsync();
     }

//I don't know how to spell it.
//What does the symbol **_ mean**?

        public void Connect(string ipAddress, int port)
        {
            _client = new TcpClient();
            _client.Connect(ipAddress, port);

            // Start a separate task to receive data
            _ = ReceiveDataAsync();

            // _ = Task.Run(async () => await ReceiveDataAsync());
			// ** is that the same? But here also, what does it mean, only _
        }

Three problems First. I want the server to send an event to the client. How can I achieve this?

The client is open, the server closes, then the client should automatically reconnect as soon as the server is available.

Second The same the other way around. How can I achieve this?

Third

public async Task SendMessage(string message)
{   
    byte[] response = Encoding.ASCII.GetBytes(message.ToUpper() + Environment.NewLine);
    await stream.WriteAsync(response, 0, message.Length);
}

Form Server, green wavy line, await, but how?

enter image description here

Stream I think I need it global, because the server can send something like an event. Is this was good?

enter image description here

On client site I never get the info of disconnection of server, maybe a bug on this sample. Have you an idea? See there. **########## Server or client disconnected **

/// <summary> /// Handle incoming data from the server /// </summary> private async Task ReceiveDataAsync() {

  NetworkStream stream = _client.GetStream();
  byte[] buffer = new byte[1024];
  StringBuilder messageBuilder = new StringBuilder();

  while (true)
  {
      int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);

      if (bytesRead == 0)
      {
          break; // ########## Server or client disconnected
      }

enter image description here

Deleted

This comment has been deleted due to a violation of our Code of Conduct. The comment was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.
Starry Night 625 Reputation points

2025-10-30T07:49:42.9533333+00:00

One thread, one problem. For all your questions, you can create a new thread for each one to discuss them. We are all willing to help you. :)
Noah Aas 1,210 Reputation points

2025-11-02T14:12:03.9733333+00:00

We are all willing to help you. :)

OK, can you look there please?

https://learn.microsoft.com/en-us/answers/questions/5600683/cancellationtokensource-stream-problem?page=1&orderby=helpful&comment=answer-12317124&translated=false#newest-answer-comment

Answer accepted by question author

0 additional answers

Your answer

Deleted

This comment has been deleted due to a violation of our Code of Conduct. The comment was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.
Starry Night 625 Reputation points

2025-10-30T07:49:42.9533333+00:00

One thread, one problem. For all your questions, you can create a new thread for each one to discuss them. We are all willing to help you. :)
Noah Aas 1,210 Reputation points

2025-11-02T14:12:03.9733333+00:00

We are all willing to help you. :)

OK, can you look there please?

https://learn.microsoft.com/en-us/answers/questions/5600683/cancellationtokensource-stream-problem?page=1&orderby=helpful&comment=answer-12317124&translated=false#newest-answer-comment

Answer 1

Bruce (SqlWork.com) 82,146 Volunteer Moderator

Because it client / server, the client always connects to the server.

the client needs a loop. When it tries to connect it may fail. The client should delay and try again. When connected, it may lose the connection, so it should go back to the connect loop.

the server just waits for a connection. If the connection is lost, it goes back to waiting.

both the client and need to keep track of the connection status. If live they can send a message, if not then wait until the connection is restored. Detecting lost connection will typically happen on a message send. App often implements a ping/keep alive message they send to more quickly detect a lost connection .

Noah Aas 1,210 Reputation points

2025-10-25T06:42:41.2133333+00:00
Thanks for the answer!

int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length); if (bytesRead == 0)

When the connection is lost, the server closes.

How and where should the client find out about this? Can you make a sample?

_client = new TcpClient(); _client.Connect(ipAddress, port); // Start a separate task to receive data _ = ReceiveDataAsync();

_ = ReceiveDataAsync();

Can you say about this something? Can you write that differently? More clearly or definitively? The symbol _ means nothing to me. Thanks
Bruce (SqlWork.com) 82,146 Reputation points Volunteer Moderator

2025-10-25T18:09:23.0033333+00:00

TCP is duplex stream. The reader typically can not detect lost connection between network packets unless sender closes the connection with a fin.

So you typically detect the connection is lost via a send that fails. If the connection is read only, then you need a timeout to close the connection if no data received in a time period.
Bruce (SqlWork.com) 82,146 Reputation points Volunteer Moderator

2025-10-25T18:14:12.8233333+00:00

There are a lot of edge conditions to handle in a protocol like this. You should probably use a tested message / response library. Microsoft has little in this space other than adding webserver protocol support to the server app (easy with .net core). Try gRPC

https://grpc.io

if you want to write your own, I’d prefix the xml with a header that had length, of a special prefix packet and trailer packet
Noah Aas 1,210 Reputation points

2025-10-28T15:29:04.88+00:00
int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length); if (bytesRead == 0)

The problem is that I can't get there when the client closes. Why not? Any tip?
Bruce (SqlWork.com) 82,146 Reputation points Volunteer Moderator

2025-10-30T01:40:25.86+00:00

Typically a stream read can not detect a lost connection. The socket is open and waiting for a packet. A write will fail because the sender will not get an ack in the timeout period.

the typical solution is to have a timeout with heartbeats. This means heartbeat packets must be sent between long delays between messages. Say you pick a 5 minute timeout. The client app if it has no messages to send, still needs to send a heartbeat before the timeout to keep the connection alive.

you can also do something http. Open and close the connection for each message. Then implement a keep-alive, where the connection is held open for say a minute after a message, so if several message are sent in a burst, the same connection can be used.
Noah Aas 1,210 Reputation points

2025-11-02T14:12:57.8066667+00:00

Please help me on other thread. Thanks!

Share via

Server/Client TCP/IP Sample

0 additional answers

Your answer