Difference Between Synchronous and Asynchronous Communication in Network Programming
The key difference between synchronous and asynchronous communication can be explained with an example.
Consider a server application that is listening on a specific port to get data from clients. In synchronous receiving, while the server is waiting to receive data from a client, if the stream is empty then the main thread will block until the request for data is satisfied. Hence, the server cannot do anything else until it receives data from the client. If another client attempts to connect to the server at that time, the server cannot process that request because it is blocked on the first client. This behavior is not acceptable for a real-world application where we need to support multiple clients at the same time.
In asynchronous communication, while the server is listening or receiving data from a client, it can still process connection requests from other clients as well as receive data from those clients. When a server is receiving asynchronously, a separate thread (at the OS level) listens on the socket and will invoke a callback function (specified when the asynchronous listening was commenced) when a socket event occurs. This callback function in turn will respond and process that socket event. For example, if the remote program writes some data to the socket, a "read data event" (callback function we specify) is invoked which knows how to read the data from the socket at that point.
Even though this could be achieved by running multiple threads, the C# and .NET frameworks provide us with a rich set of functionalities to do asynchronous communications without introducing the complexity of threading.
Socket Class
The Socket class (System.Net.Sockets.Socket) provides a set of synchronous and asynchronous methods for synchronous or asynchronous communication. As per the .NET naming convention, all the asynchronous method names are created by prefixing the words "Begin" or "End" to the name of the synchronous methods. The methods prefixed with "Begin" and "End" represent a pair of asynchronous methods corresponding to a single synchronous method, as shown in the following table.
| Synchronous Methods |
Asynchronous Methods |
Connect() |
BeginConnect()
EndConnect() |
Receive() |
BeginReceive()
EndReceive() |
Example Application
The example shown in this article has two classes, one implementing the Socket Server and the other implementing the Socket Client.
Socket Server Implementation
The Socket Server application is implemented in the SocketServer class (file name SocketServer.cs). This class has a main Socket object (m_mainSocket) and an array of worker Socket objects (m_workerSocket) as members. The main Socket object does the listening for the clients. Once a client is connected, the main Socket transfers the responsibility to process the transactions related to that particular client to a worker Socket. Then, the main Socket goes back and continues listening for other clients.
BeginAccept() and BeginReceive() are the two important methods in the Socket class used by the Socket Server application.
The BeginAccept() method has the following signature:
public IAsyncResult BeginAccept( AsyncCallback callback, object state );
Essentially, after calling the Listen() method of the main Socket object, we call this asynchronous method and specify a call back function (1), which we designated to do the further processing related to the client connection. The state object (2) can be null in this particular instance.
Because this is an asynchronous method, it will return immediately and the server main thread is free to process other events. Behind the scenes, a separate thread will start listening on that particular socket for client connections. When a client requests a connection, the callback function we specified will be invoked.
Inside the callback function (in our example, the function is named "OnClientConnect()"), we will do further processing related to the client connection.
public void OnClientConnect(IAsyncResult asyn) { try { m_workerSocket[m_clientCount] = m_mainSocket.EndAccept (asyn); WaitForData(m_workerSocket[m_clientCount]); ++m_clientCount; String str = String.Format("Client # {0} connected", m_clientCount); textBoxMsg.Text = str; m_mainSocket.BeginAccept(new AsyncCallback ( OnClientConnect ),null); } catch(ObjectDisposedException) { System.Diagnostics.Debugger.Log(0,"1","\n OnClientConnection: Socket has been closed\n"); } catch(SocketException se) { MessageBox.Show ( se.Message ); } }
The first thing we do inside the "OnClientConnect()" function is to call the EndAccept() method on the m_mainSocket member object, which will return a reference to another socket object. We set this object reference to one of the members of the array of Socket object references we have (m_workerSocket) and also increment the client counter. Now, because we have a reference to a new socket object that now can do the further transaction with the client, the main Socket (m_mainSocket) is free; hence, we will call its BeginAccept() method again to start waiting for connection requests from other clients.
On the worker socket, we use a similar strategy to receive the data from the client. In place of calling BeginAccept() and EndAccept(), here we call BeginReceive() and EndReceive(). This, in a nutshell, is the Socket Server implementation. While we are sending out data to the clients, the server simply uses the specific worker socket objects to send data to each client.
Socket Client Implementation
(Full Size Image)
The Socket Client application is implemented in the SocketClient class (file name SocketClient.cs). Compared to the server where we have a main Socket and an array of worker Sockets, here we only have a single Socket object (m_clientSocket).
The two important methods in Socket class used by the Socket Client application are the Connect() and BeginReceive() method. Connect() is a synchronous method and is called to connect to a server that is listening for client connections. Because this call will succeed/fail immediately, depending on whether there is an active server listening or not at the specified IP and Port number, a synchronous method is okay for this purpose.
Once a connection is established, we call the BeginReceive() asynchronous function to wait for any socket write activity by the server. Here, if we call a synchronous method, the main thread on the client application will block and we will not be able to send any data to the server while the client is waiting for data from the server.
When there is any write activity on the socket from the server end, the internal thread started by BeginReceive() will invoke the callback function ("OnDataReceived()" in our case), which will take care of the further processing of the data written by the server.
When sending the data to the server, we just call the Send() method on the m_clientSocket object, which will synchronously write the data to the socket.
That is all there is for asynchronous socket communication using multiple clients.
Limitations/Possible Improvements
- Up to 10 simultaneous clients are supported. You can easily modify and support unlimited number of clients by using a HashTable instead of an array.
- For simplicity, when the server sends out a message, it is broadcast to all the connected clients. This could easily be modified to send messages to specific clients by using the Socket object pertaining to that particular client.
- When a client is disconnected, proper action is not taken; the client count is not decremented. The correct way would be to reuse or release resources for other client connections.
Downloads
async_client_server_exe.zip - Windows Executable Files
async_client_server_src.zip - C# Source Code
