C# - Server / Client

Heute möchte ich euch kurz die Kommunikation zwischen zwei Computern über TCP/IP vorstellen.

Wir werden in diesem Beispiel einen Client und einen Server verwenden.

Der Server ist aber so aufgebaut, dass er mehrere Clients gleichzeitig bearbeiten kann.

Beginnen wir mit dem Aufbau des Servers.

Server Programm:

Wir erstellen eine neue Consolen Anwendung.

Als erstes erstellen wir eine Funktion StartServer();

Da der Server auf die locale (eigene) IP Adresse hören soll, habe ich dafür eine eigene Funktion erstellt.

In der Funktion StartServer() erstellen wir einen neuen TcpListener und rufen die Funktion WaitForClientConnect() auf.

In WaitForClientConnect() bearbeiten wir alle eingehenden Verbindungen zu dem Server.

Dazu erstellen wir für jeden neuen Client einen eigenen Thread.

Dies dient dazu, wenn der Verbindungsaufbau zu Server länger dauert, die restliche Funktionalität nicht beeinflusst wird.

In OnClientConnect() erstellen wir ein neues Objekt TcpClient vom eingehenden Client und übergeben das der Klasse HandleClientRequest.

Anschließend starten wir die Kommunikation mit dem Client, clientReq.StartClient();

In der Klasse HandleClientRequest schaut das Initialisieren folgendermaßen aus:

Es wird der TcpClient verwendet welcher im Hauptprogramm erstellt wurde.

Die StartClient() Funktion ließt die Nachrichten vom Client und geht dann wieder in einen „Warte-Modus“ für neue Nachrichten.

Jetzt fehlt noch die Nachrichtenverarbeitung, die wie folgt aussieht.

In WaitForRequest() beginnen wir mit dem Lesen der Nachricht und verwenden dabei die asynchrone Funktion ReadCallback.

Die Funktion ReadCallback sendet anschließen auch eine Nachricht zurück an den Client.

Zum Schluss müssen wir den Server noch einsatzbereit machen indem wir die StartServer() Funktion aufrufen.

Client Programm:

Wir erstellen wieder eine Consolen Anwendung.

Wir erstellen zuerst einen neue Klasse TCPClient.

Die Klasse enthält folgenden Funktionen:

• ConnectToServer
• ClosConnection
•  SendData
• ReceiveData

Funktion ConnectToServer:

Hier erstellen wir ein TCP Objekt welches zum Server zeigt.

Server IP durch die IP Adresse vom Server ersetzen.

Funktion CloseConnection:

Hier wird die aktuelle Verbindung geschlossen.

Funktion SendData:

Es wird die zu sendende Nachricht in ein byte Array umgewandelt und anschließend an den Server gesendet. (Auf Server Seite endet dieser Aufruf in der ReadCallback Funktion)

Funktion ReceiveData:

Diese Funktion kann nach dem SendData aufgerufen werden um die Antwort vom Server zu empfangen.

Die Antwort wird von einem byte Array wieder in einen String umgewandelt.

Ein kompletter Aufruf würde dann wie folgt aussehen:

C# - Server Client application

Today I want to show a short tutorial about a server client communication via TCP/IP.
The server is able to handle more than one client at the same time.

Let´s start with the Server.

Server Program:

Create a new Console program.

First we create a new function StartServer();

Due to that the server should listen to his own IP address, I´ve prepared a separate function for this.

Within the function StartServer() we are creating a new TcpListener and calling the function WaitForClientConnect().

In WaitForClientConnect() we are handling all connections to the server.

Therefore we will start for every new connected client a new thread.

This will allow us, if a connection takes very long, the main program is still able to accept new requests.

In OnClientConnect() we are creating a new object type of TcpClient for every new client and call the class HandleClientRequest.

Then we can start the communication with clientReq.StartClient();

In the class HandleClientRequest the Initialize looks like following:

We will use the TcpClient from the main program.

The StartClient() function is reading the message from the client and afterwards the function is going in a waiting mode.

The message process looks like following:

In WaitForRequest() we are starting to read the message by using the function ReadCallback.

The function ReadCallback will send, after proceeding, the message back to the client.

At least we finish the server program by implementing the StartServer() function in the Main part.

Client Programm:

We also create a Console program.

First we create a new class TCPClient.

The class contains following functions:

• ConnectToServer
• ClosConnection
•  SendData
• ReceiveData

Funktion ConnectToServer:

Here we create a new object type of TcpClient.

Replace Server IP with the IP address from the server.

Funktion CloseConnection:

Here we are closing the active connection.

Funktion SendData:

Converts the message into a byte array and sends this array to the server.
(On server side this will end in the function ReadCallback)

Funktion ReceiveData:

This function could be called after SendData and will receive the answer from the server.

Also this answer message will be converted from a byte array into a string message.

The whole flow for the client program looks like following: