Server Client Send/Receive Simple Text

Server Client send/receive simple text

The following code send and recieve the current date and time from and to the server

//The following code is for the server application:

namespace Server
{
    class Program
    {
        const int PORT_NO = 5000;
        const string SERVER_IP = "127.0.0.1";

        static void Main(string[] args)
        {
            //---listen at the specified IP and port no.---
            IPAddress localAdd = IPAddress.Parse(SERVER_IP);
            TcpListener listener = new TcpListener(localAdd, PORT_NO);
            Console.WriteLine("Listening...");
            listener.Start();

            //---incoming client connected---
            TcpClient client = listener.AcceptTcpClient();

            //---get the incoming data through a network stream---
            NetworkStream nwStream = client.GetStream();
            byte[] buffer = new byte[client.ReceiveBufferSize];

            //---read incoming stream---
            int bytesRead = nwStream.Read(buffer, 0, client.ReceiveBufferSize);

            //---convert the data received into a string---
            string dataReceived = Encoding.ASCII.GetString(buffer, 0, bytesRead);
            Console.WriteLine("Received : " + dataReceived);

            //---write back the text to the client---
            Console.WriteLine("Sending back : " + dataReceived);
            nwStream.Write(buffer, 0, bytesRead);
            client.Close();
            listener.Stop();
            Console.ReadLine();
        }
    }
}

//this is the code for the client

namespace Client
{
    class Program
    {
        const int PORT_NO = 5000;
        const string SERVER_IP = "127.0.0.1";
        static void Main(string[] args)
        {
            //---data to send to the server---
            string textToSend = DateTime.Now.ToString();

            //---create a TCPClient object at the IP and port no.---
            TcpClient client = new TcpClient(SERVER_IP, PORT_NO);
            NetworkStream nwStream = client.GetStream();
            byte[] bytesToSend = ASCIIEncoding.ASCII.GetBytes(textToSend);

            //---send the text---
            Console.WriteLine("Sending : " + textToSend);
            nwStream.Write(bytesToSend, 0, bytesToSend.Length);

            //---read back the text---
            byte[] bytesToRead = new byte[client.ReceiveBufferSize];
            int bytesRead = nwStream.Read(bytesToRead, 0, client.ReceiveBufferSize);
            Console.WriteLine("Received : " + Encoding.ASCII.GetString(bytesToRead, 0, bytesRead));
            Console.ReadLine();
            client.Close();
        }
    }
}

Server Client send/receive multiple clients

Do not use any low-level Socket libraries like TcpListener or System.Net.Sockets unless you are trying to learn socket programming or doing a school project. There are plenty of well-supported .NET libraries for doing client-server communication that handle low level sockets and multi-threading for you so you can focus on your business rules.

Will the final server run on IIS? If yes, look into using SignalR. It supports both client and server and has advance user management on the server side so the server can send replies or data to individual clients or whole groups based on custom criteria.

If you cannot use IIS, try NetCoreServer, It features async client and server and has examples using TCP, UDP, HTTP, and WebSockets.

There are multiple other libraries to consider. If you do decide to use sockets take a look at the list in this answer.

Update

Since this is for a school project where socket programming is a requirement, you can do the following.

Server

Use a tread-safe collection like a ConcurrectDictionary to store connected clients
Each client object would use events to receive data from its client as well as detect a client disconnect
The server would subscribe to those events and do whatever it needs when a message is received
When the server does any client operation like sending messages, it needs to lock the operation to avoid deadlocks
When a client disconnects, make sure to unsubscribe from any subscriptions for this client to avoid memory leaks
Here is a good example

Client

Can use TCPClient or plain Socket and SocketAsyncEventArgs
You can look at SocketAsyncEventArgs to check when an operation completes
You can use async sockets so you do not need to do threads manually
Here is a good example and here is another

In simple C# tcp client/server program, I send 5 bytes, server sees over 400,000. What is happening?

clientSocket.ReceiveBufferSize

Returns the size of the receive buffer which does not align with the amount of received bytes. Use the Read method of your network stream (serverStream) and check its result which tells you how many bytes have been read.

See NetworkStream.Read(Byte[], Int32, Int32) Method and TcpClient.GetStream for more info.

How can I send multiple string messages from client to server using a single instance of TcpClient?

If you debug your server, you'll see that it does receive data. You're just not displaying the data, because the only output your server does is after the loop when the byte count returned is 0: Console.WriteLine($"Message:{ dataReceived }\n");. The byte count will only be 0 when the underlying socket has been shutdown. That never happens because your client is stuck in an infinite loop.

A better approach, for a simple text-based client/server example like this, is to use StreamWriter and StreamReader with line-based messages, i.e. WriteLine() and ReadLine(). Then the line breaks serve as the message delimited, and your server can write the message each time it receives a new line.

Note also that in your example above, you are assuming that each chunk of data contains only complete characters. But you're using UTF8 where characters can be two or more bytes, and TCP doesn't guarantee how bytes that are sent are grouped. Using StreamWriter and StreamReader will fix this bug too, but if you wanted to do it explicitly yourself, you can use the Decoder class, which will buffer partial characters.

For some examples of how to correctly implement a simple client/server network program like that, see posts like these:

.NET Simple chat server example

C# multithreading chat server, handle disconnect

C# TcpClient: Send serialized objects using separators?

Sending a value from server to client with sockets

Answers to the questions first:

Q: Is it necessary to convert everything to string?...In general what I
want is to send a variable from one computer to two others in order a
process to begin simultaneously in all computers.

A: No, it is not necessary to convert everything to string when sending
using Socket. You may send byte[] which you most probably want.

Q: What I want to achieve is to send a boolean variable from the server
to the client with the sockets

A: Do you mean boolean or byte? Because the basic variable type which you
will get from the Socket is byte. You could always change byte
to bool from the sender/receiver side by doing like

bool val = byteToCheck > 0;

A2: And since your server is Console Application, I recommend to take
a look on hex string to byte[] conversion. This way, you could
write something in string but interprets it as byte[]. Check
this. The whole idea here is pretty simple. That is: you type in
string, but it will be sent as byte[]. And since it is byte[]
you can have any value in it.

And here I present my solution to handle your (1) multiple clients, (2) Async connect & accept & receive, but having (3) send sync, as well as (4) conversion from hex string to byte[] (the structure & idea), and last but not least (5) working code with user input (for you to change this part) for testing!

I would solve such problem using simple Socket class, since it is the solution I am most familiar with. But you could always do similarly if you use your TcpListener.Server (which is the underlying network of Socket class). And, as you desire, I would do that with ASync.

There are several steps needed to achieve what you want in both your server and your client:

Server

Make your Socket as class field rather than method field, since you will use if everywhere and you need multiple methods to achieve what you want. And initialize it as soon as you started your main routine.

const int PORT_NO = 2201;
const string SERVER_IP = "127.0.0.1";
static Socket serverSocket; //put here as static
static void Main(string[] args) {
    //---listen at the specified IP and port no.---
    Console.WriteLine("Listening...");
    serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT_NO));
    serverSocket.Listen(4); //the maximum pending client, define as you wish
    //your next main routine
}

Since the server will serve many clients, I will recommend you to use ASync rather than Sync for the process. Initialize your Socket by using BeginAccept rather than using Accept, put acceptCallback in your BeginAccept

static void Main(string[] args) {
    //---listen at the specified IP and port no.---
    Console.WriteLine("Listening...");
    serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT_NO));
    serverSocket.Listen(4); //the maximum pending client, define as you wish
    serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);      
    //other stuffs
}

Define acceptCallback, which is where you will go when you accept a Socket. Put EndAccept there.

private void acceptCallback(IAsyncResult result) { //if the buffer is old, then there might already be something there...
    System.Net.Sockets.Socket socket = null;
    try {
        socket = serverSocket.EndAccept(result); // To get your client socket
        //do something later
    } catch (Exception e) { // this exception will happen when "this" is be disposed...        
        //do something later
    }
}

I would typically list my client sockets, and do something on client disposal (that is unlisted it) - but this depends on the need. In this case, you seem to need it. And don't forget to create buffers, etc... This is for buffering the incoming data.

Start to accept something received from the client, using another ASync BeginReceive on the client Socket (and now you need receiveCallback). Then, very important, repeat your BeginAccept to accept other clients!

private const int BUFFER_SIZE = 4096;
private static byte[] buffer = new byte[BUFFER_SIZE]; //buffer size is limited to BUFFER_SIZE per message
private static List<Socket> clientSockets = new List<Socket>(); //may be needed by you
private static void acceptCallback(IAsyncResult result) { //if the buffer is old, then there might already be something there...
    Socket socket = null;
    try {
        socket = serverSocket.EndAccept(result); // The objectDisposedException will come here... thus, it is to be expected!
        //Do something as you see it needs on client acceptance such as listing
        clientSockets.Add(socket); //may be needed later
        socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
        serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null); //to receive another client
    } catch (Exception e) { // this exception will happen when "this" is be disposed...        
        //Do something here
        Console.WriteLine(e.ToString());
    }
}

Define your receiveCallback, that is, when you receive something from your client. This part could be quite tricky because of failures! But basically, what you need for now is simply EndReceive and again, very important, to repeat the BeginReceive from the same client such that you can receive its next message!

const int MAX_RECEIVE_ATTEMPT = 10;
static int receiveAttempt = 0; //this is not fool proof, obviously, since actually you must have multiple of this for multiple clients, but for the sake of simplicity I put this
private static void receiveCallback(IAsyncResult result) {
    Socket socket = null;
    try {
        socket = (Socket)result.AsyncState; //this is to get the sender
        if (socket.Connected) { //simple checking
            int received = socket.EndReceive(result);
            if (received > 0) {
                byte[] data = new byte[received]; //the data is in the byte[] format, not string!
                Buffer.BlockCopy(buffer, 0, data, 0, data.Length); //There are several way to do this according to https://stackoverflow.com/questions/5099604/any-faster-way-of-copying-arrays-in-c in general, System.Buffer.memcpyimpl is the fastest
                //DO SOMETHING ON THE DATA IN byte[] data!! Yihaa!!
                Console.WriteLine(Encoding.UTF8.GetString(data)); //Here I just print it, but you need to do something else
                receiveAttempt = 0; //reset receive attempt
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
            } else if (receiveAttempt < MAX_RECEIVE_ATTEMPT) { //fail but not exceeding max attempt, repeats
                ++receiveAttempt; //increase receive attempt;
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
            } else { //completely fails!
                Console.WriteLine("receiveCallback fails!"); //don't repeat beginReceive
                receiveAttempt = 0; //reset this for the next connection
            }
        }
    } catch (Exception e) { // this exception will happen when "this" is be disposed...
        Console.WriteLine("receiveCallback fails with exception! " + e.ToString());
    }
}

And suppose you want to reply your sender after you receive the message, simply do this in the if (received > 0) part:

if (received > 0) {
    byte[] data = new byte[received]; //the data is in the byte[] format, not string!
    //DO SOMETHING ON THE DATA int byte[]!! Yihaa!!
    Console.WriteLine(Encoding.UTF8.GetString(data)); //Here I just print it, but you need to do something else                     

    //Message retrieval part
    //Suppose you only want to declare that you receive data from a client to that client
    string msg = "I receive your message on: " + DateTime.Now;
    socket.Send(Encoding.ASCII.GetBytes(msg)); //Note that you actually send data in byte[]
    Console.WriteLine("I sent this message to the client: " + msg);

    receiveAttempt = 0; //reset receive attempt
    socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
}

And after putting a little more things in your main routine, you are done(!) - IF you do not ask for sending to client as byte[]

And now, if you want to send something to all your clients as byte[] you simply need to list all your client (see step 4-5). See this and convert the result string above (remember to type it in hex string format as required) to byte[] then send it to all the clients using your client socket list (here is where it is needed!):

static void Main(string[] args) {
    //---listen at the specified IP and port no.---
    Console.WriteLine("Listening...");
    serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT_NO));
    serverSocket.Listen(4); //the maximum pending client, define as you wish
    serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);      

    //normally, there isn't anything else needed here
    string result = "";
    do {
        result = Console.ReadLine();
        if (result.ToLower().Trim() != "exit") {
            byte[] bytes = null;
            //you can use `result` and change it to `bytes` by any mechanism which you want
            //the mechanism which suits you is probably the hex string to byte[]
            //this is the reason why you may want to list the client sockets
            foreach(Socket socket in clientSockets)
                socket.Send(bytes); //send everything to all clients as bytes
        }
    } while (result.ToLower().Trim() != "exit");
}

And here, you are more or less done with your server. Next is your client

Client:

Similarly, put the Socket class in the class context rather than method context and initialize it as soon as you start your program

const int PORT_NO = 2201;
const string SERVER_IP = "127.0.0.1";
static Socket clientSocket; //put here
static void Main(string[] args) {
    //Similarly, start defining your client socket as soon as you start. 
    clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

    //your other main routines
}

Then start to connect by ASync BeginConnect. I would normally go further by LoopConnect just for failure handling like this.

static void loopConnect(int noOfRetry, int attemptPeriodInSeconds) {
    int attempts = 0;
    while (!clientSocket.Connected && attempts < noOfRetry) {
        try {
            ++attempts;
            IAsyncResult result = clientSocket.BeginConnect(IPAddress.Parse(SERVER_IP), PORT_NO, endConnect, null);
            result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(attemptPeriodInSeconds));
            System.Threading.Thread.Sleep(attemptPeriodInSeconds * 1000);
        } catch (Exception e) {
            Console.WriteLine("Error: " + e.ToString());
        }
    }
    if (!clientSocket.Connected) {
        Console.WriteLine("Connection attempt is unsuccessful!");
        return;
    }
}

Similar concept to what you do to the server BeginAccept you need to define endConnectCallback for the ASync BeginConnect you use. But here, unlike server which needs to re-calling BeginAccept, once you are connected, you do not need to do any new BeginConnect since you only need to be connected once.

You may want to declare buffer etc. Then, after you connect, don't forget the next ASync BeginReceive to handle the message retrieval part (similar with the server)

private const int BUFFER_SIZE = 4096;
private static byte[] buffer = new byte[BUFFER_SIZE]; //buffer size is limited to BUFFER_SIZE per message
private static void endConnectCallback(IAsyncResult ar) {
    try {
        clientSocket.EndConnect(ar);
        if (clientSocket.Connected) {
            clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), clientSocket);
        } else {
            Console.WriteLine("End of connection attempt, fail to connect...");
        }
    } catch (Exception e) {
        Console.WriteLine("End-connection attempt is unsuccessful! " + e.ToString());
    }
}

Naturally, you need to define your receiveCallback, just like what you did for the server. And yes, it is as you have guessed, it is almost identical to what you did for the server!

You can do anything you want with your data. Note that the data you receive is actually in byte[], not string. So you can do anything with it. But for example's sake, I will just use string to display.

const int MAX_RECEIVE_ATTEMPT = 10;
static int receiveAttempt = 0;
private static void receiveCallback(IAsyncResult result) {
    System.Net.Sockets.Socket socket = null;
    try {
        socket = (System.Net.Sockets.Socket)result.AsyncState;
        if (socket.Connected) {
            int received = socket.EndReceive(result);
            if (received > 0) {
                receiveAttempt = 0;
                byte[] data = new byte[received];
                Buffer.BlockCopy(buffer, 0, data, 0, data.Length); //copy the data from your buffer
                //DO ANYTHING THAT YOU WANT WITH data, IT IS THE RECEIVED PACKET!
                //Notice that your data is not string! It is actually byte[]
                //For now I will just print it out
                Console.WriteLine("Server: " + Encoding.UTF8.GetString(data));
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
            } else if (receiveAttempt < MAX_RECEIVE_ATTEMPT) { //not exceeding the max attempt, try again
                ++receiveAttempt;
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
            } else { //completely fails!
                Console.WriteLine("receiveCallback is failed!");
                receiveAttempt = 0;
                clientSocket.Close();
            }
        }
    } catch (Exception e) { // this exception will happen when "this" is be disposed...
        Console.WriteLine("receiveCallback is failed! " + e.ToString());
    }
}

And at the very very last... Yes, again, as you have already guessed, you just need to do something on your main routine - suppose you want to use it to send data. Because you use Console but you want it to send things as byte[], you need to do the conversion (see the explanation in server 9.). And afterwards you are completely done!!

static void Main(string[] args) {
    //Similarly, start defining your client socket as soon as you start. 
    clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    loopConnect(3, 3); //for failure handling
    string result = "";
    do {
        result = Console.ReadLine(); //you need to change this part
        if (result.ToLower().Trim() != "exit") {
            byte[] bytes = Encoding.ASCII.GetBytes(result); //Again, note that your data is actually of byte[], not string
            //do something on bytes by using the reference such that you can type in HEX STRING but sending thing in bytes
            clientSocket.Send(bytes);
        }
    } while (result.ToLower().Trim() != "exit");
}

Results:

Here you go! I tested it by sending string for display, but I already put up what is needed when you want to change it to byte[]

Sample Image

Code for your test:

Server

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace TcpListenerConsoleApplication {
    class Program {
        const int PORT_NO = 2201;
        const string SERVER_IP = "127.0.0.1";
        static Socket serverSocket;
        static void Main(string[] args) {
            //---listen at the specified IP and port no.---
            Console.WriteLine("Listening...");
            serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            serverSocket.Bind(new IPEndPoint(IPAddress.Any, PORT_NO));
            serverSocket.Listen(4); //the maximum pending client, define as you wish
            serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);      
            string result = "";
            do {
                result = Console.ReadLine();
            } while (result.ToLower().Trim() != "exit");
        }

        private const int BUFFER_SIZE = 4096;
        private static byte[] buffer = new byte[BUFFER_SIZE]; //buffer size is limited to BUFFER_SIZE per message
        private static void acceptCallback(IAsyncResult result) { //if the buffer is old, then there might already be something there...
            Socket socket = null;
            try {
                socket = serverSocket.EndAccept(result); // The objectDisposedException will come here... thus, it is to be expected!
                //Do something as you see it needs on client acceptance
                socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
                serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null); //to receive another client
            } catch (Exception e) { // this exception will happen when "this" is be disposed...        
                //Do something here             
                Console.WriteLine(e.ToString());
            }
        }

        const int MAX_RECEIVE_ATTEMPT = 10;
        static int receiveAttempt = 0; //this is not fool proof, obviously, since actually you must have multiple of this for multiple clients, but for the sake of simplicity I put this
        private static void receiveCallback(IAsyncResult result) {
            Socket socket = null;
            try {
                socket = (Socket)result.AsyncState; //this is to get the sender
                if (socket.Connected) { //simple checking
                    int received = socket.EndReceive(result);
                    if (received > 0) {
                        byte[] data = new byte[received]; //the data is in the byte[] format, not string!
                        Buffer.BlockCopy(buffer, 0, data, 0, data.Length); //There are several way to do this according to https://stackoverflow.com/questions/5099604/any-faster-way-of-copying-arrays-in-c in general, System.Buffer.memcpyimpl is the fastest
                        //DO SOMETHING ON THE DATA int byte[]!! Yihaa!!
                        Console.WriteLine(Encoding.UTF8.GetString(data)); //Here I just print it, but you need to do something else                     

                        //Message retrieval part
                        //Suppose you only want to declare that you receive data from a client to that client
                        string msg = "I receive your message on: " + DateTime.Now;                      
                        socket.Send(Encoding.ASCII.GetBytes(msg)); //Note that you actually send data in byte[]
                        Console.WriteLine("I sent this message to the client: " + msg);

                        receiveAttempt = 0; //reset receive attempt
                        socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
                    } else if (receiveAttempt < MAX_RECEIVE_ATTEMPT) { //fail but not exceeding max attempt, repeats
                        ++receiveAttempt; //increase receive attempt;
                        socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket); //repeat beginReceive
                    } else { //completely fails!
                        Console.WriteLine("receiveCallback fails!"); //don't repeat beginReceive
                        receiveAttempt = 0; //reset this for the next connection
                    }
                }
            } catch (Exception e) { // this exception will happen when "this" is be disposed...
                Console.WriteLine("receiveCallback fails with exception! " + e.ToString());
            }
        }

    }
}

Client

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace TcpClientConsoleApplication {
    class Program {
        const int PORT_NO = 2201;
        const string SERVER_IP = "127.0.0.1";
        static Socket clientSocket; //put here
        static void Main(string[] args) {
            //Similarly, start defining your client socket as soon as you start. 
            clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            loopConnect(3, 3); //for failure handling
            string result = "";
            do {
                result = Console.ReadLine(); //you need to change this part
                if (result.ToLower().Trim() != "exit") {
                    byte[] bytes = Encoding.ASCII.GetBytes(result); //Again, note that your data is actually of byte[], not string
                    //do something on bytes by using the reference such that you can type in HEX STRING but sending thing in bytes
                    clientSocket.Send(bytes);
                }
            } while (result.ToLower().Trim() != "exit");
        }

        static void loopConnect(int noOfRetry, int attemptPeriodInSeconds) {
            int attempts = 0;
            while (!clientSocket.Connected && attempts < noOfRetry) {
                try {
                    ++attempts;
                    IAsyncResult result = clientSocket.BeginConnect(IPAddress.Parse(SERVER_IP), PORT_NO, endConnectCallback, null);
                    result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(attemptPeriodInSeconds));
                    }
                }
            }

Server Client Send/Receive Simple Text