Sending messages to the server on multithread client application

I really think you should use Async methods if you intend to make an async server.

This is a very basic async server that sends whatever it receives to all connected clients.

You can run it like this:

Server s = new Server(1338); s.startListening(); 

Try connecting your client to it:

class Server { private int port; private Socket serverSocket; private List<StateObject> clientList; private const int DEFAULT_PORT = 1338; public Server() { this.port = 1338; //default port serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); clientList = new List<StateObject>(); } public Server(int port) { this.port = port; serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); clientList = new List<StateObject>(); } public void startListening(int port = DEFAULT_PORT) { this.port = port; //Bind to our port serverSocket.Bind(new IPEndPoint(IPAddress.Any, this.port)); //Listen on the port serverSocket.Listen(1); //Async Method to wait for a client to connect serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null); } private void AcceptCallback(IAsyncResult AR) { try { //A client has connected so create a stateobject for them //This will hold their buffer and socket StateObject state = new StateObject(); //This is where the socket is passed to our state state.workSocket = serverSocket.EndAccept(AR); //Add this client to our client list clientList.Add(state); //Async method to receive data from them (Non Blocking) state.workSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveCallback), state); //Immediately go back to waiting for a new client (Non Blocking) serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null); } catch { } } private void ReceiveCallback(IAsyncResult AR) { //A client has sent us data //We pass ourselves the state in our previous method //Now we can retrieve that StateObject from the callback StateObject state = (StateObject)AR.AsyncState; //Use this to get the socket so we can retrieve the data from it Socket s = state.workSocket; //Variable to hang on to the amount of data we received int received = 0; //Call the socket EndReceive Method received = s.EndReceive(AR); //If we received no data from the client, they have disconnected if (received == 0) { //Remove them from our clientlist clientList.Remove(state); //Tell the other clients that they have left foreach (StateObject others in clientList) others.workSocket.Send(Encoding.ASCII.GetBytes("Client disconnected " + s.LocalEndPoint)); //We return here - this callback thread is now dead. return; } //If we received data if (received > 0) { //Append the data to our StringBuilder state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, received)); } //Build the string and let's see if it contains a new line character string content = state.sb.ToString(); //If the data has a new line character if(content.Contains("\n") && content.Length > 1) { //Send this data to every other client foreach (StateObject others in clientList) if (others != state) //Make sure we don't send it back to the sender others.workSocket.Send(Encoding.ASCII.GetBytes(content.ToCharArray())); state.sb.Clear(); //Clear their StringBuilder so we can retrieve the next message } //Clear the temporary buffer Array.Clear(state.buffer, 0, StateObject.BufferSize); //And prepare to receive more data s.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state); } } class StateObject { public Socket workSocket = null; public const int BufferSize = 1024; public byte[] buffer = new byte[BufferSize]; public StringBuilder sb = new StringBuilder(); } 

Some explanation:

No problem at all. I didn't really understand them either so I steered clear of them for too long. Basically the callback methods are registered as events. When something triggers them (like receiving data), the server executes the function. Calling BeginAccept can be thought of as creating a new thread that waits for a connection before executing the linked method.

When it receives one, it executes the AcceptCallback method that we entered as a parameter. From there, AcceptCallback sets up BeginAccept again which waits for a new connection as well as BeginReceive which waits for data to be sent from the client.

Neither of these methods block execution (think of it as creating a new thread and starting it) and as soon as they are triggered their respective functions are called.

Each client is assigned a StateObject that contains their socket and a buffer, and these are put in a list that we can loop through and access.

The StateObject is passed as a parameter with the async calls so that we can tell which client sent the data and store it in a separate buffer.

Second edit:

Your client receive code looks okay. The server will not respond with data to the client sending data. If I sent the server "Hello!" it will forward that message to all other connected clients. If you want to try receiving something, connect 2 clients. Or, you can simply remove the line of code if (others != state) //Make sure we don't send it back to the sender

I wrote a client/server for chat purposes and the code can be found here:

Async chat server buffer issue