Dot Net Socket Programming-1 : Asynchronous Socket Server

To use socket asynchronously Microsoft has provide very helpful technology in .Net. We just use some inbuilt functions with ‘Begin-End’ scenario with three word ‘Accept, Send & Receive’. These functions are:

BeginAccept() - EndAccept()
BeginReceive() - EndReceive()
BeginSend() - EndSend()

These functions, when invoked, create & start internal threads and each works on a separate thread and continue working. So it doesn’t hamper main thread. Also inter-thread communication is maintained by ‘ManualResetEvent’. ManualResetEvent object handles the communication over its three functions :
Reset()
Set ()
WaitOne().

For this example, we going to make use of transfer of some string data. So we are going to use ‘StringBuilder’ for string operation instead of simple ‘string’ class. Both class does same work, but ‘StringBuilder’ is very fast than ‘string’, but you can go with ‘string’ for this example.

The exact codes we are going to use is given below. Beore the tag line I'm gonna add some of my notes- you can give that a look as well.

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

// State object for reading client data asynchronously
public class StateObject
{
// Client socket.
public Socket workSocket = null;
// Size of receive buffer.
public const int BufferSize = 1024;
// Receive buffer.
public byte[] buffer = new byte[BufferSize];
// Received data string.
public StringBuilder sb = new StringBuilder();
}

public class AsynchronousSocketListener
{
// Thread signal.
public static ManualResetEvent allDone = new ManualResetEvent(false);

public AsynchronousSocketListener()
{
}

public static void StartListening()
{
// Temp storage for incoming data.
byte[] recvDataBytes = new Byte[1024];

// Make endpoint for the socket.
//IPAddress serverAdd = Dns.Resolve("localhost"); - That line was wrong
//'baaelSiljan' has noticed it and then I've modified that line, correct line will be as:
IPHostEntry ipHost = Dns.Resolve("localhost");
IPAddress serverAdd = ipHost.AddressList[0];

IPEndPoint ep = new IPEndPoint(serverAdd, 5656);

// Create a TCP/IP socket for listner.
Socket listenerSock = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);

// Bind the socket to the endpoint and wait for listen for incoming connections.
try
{
listenerSock.Bind(ep);
listenerSock.Listen(10);

while (true)
{
// Set the event to nonsignaled state.
allDone.Reset();

// Start an asynchronous socket to listen for connections.
Console.WriteLine("Waiting for Client...");
listenerSock.BeginAccept(
new AsyncCallback(AcceptCallback),
listenerSock);

// Wait until a connection is made before continuing.
allDone.WaitOne();
}

}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}

Console.WriteLine("\nPress ENTER to continue...");
Console.Read();

}

public static void AcceptCallback(IAsyncResult ar)
{
// Signal the main thread to continue.
allDone.Set();

// Get the socket that handles the client request.
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);

// Create the state object.
StateObject state = new StateObject();
state.workSocket = handler;
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReadCallback), state);
}

public static void ReadCallback(IAsyncResult ar)
{
String content = String.Empty;

// Retrieve the state object and the handler socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workSocket;

// Read data from the client socket.
int bytesRead = handler.EndReceive(ar);

if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(
state.buffer, 0, bytesRead));

// Check for end-of-file tag. If it is not there, read
// more data.
content = state.sb.ToString();
if (content.IndexOf("") > -1)
{
// All the data has been read from the
// client. Display it on the console.
Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",
content.Length, content);
// Echo the data back to the client.
Send(handler, content);
}
else
{
// Not all data received. Get more.
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReadCallback), state);
}
}
}

private static void Send(Socket handler, String data)
{
// Convert the string data to byte data using ASCII encoding.
byte[] byteData = Encoding.ASCII.GetBytes(data);

// Begin sending the data to the remote device.
handler.BeginSend(byteData, 0, byteData.Length, 0,
new AsyncCallback(SendCallback), handler);
}

private static void SendCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object.
Socket handler = (Socket)ar.AsyncState;

// Complete sending the data to the remote device.
int bytesSent = handler.EndSend(ar);
Console.WriteLine("Sent {0} bytes to client.", bytesSent);

handler.Shutdown(SocketShutdown.Both);
handler.Close();

}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}


public static int Main(String[] args)
{
StartListening();
return 0;
}
}

Notes:

1. Why am I using Asynchronous socket and not synchronous socket ? Because using asynchronous socket we can transfer data over different threads and data can transfer more smoothly. If anyone tries to send large data without any multi-threading model then he will see that when data is being transfered, his program might look like ‘crashed’. However surely there are some advantages of Synchronous sockets over Asynchronous one.
   
2. Always keep in mind here system is using default thread pool which by default handles maximum 25 threads; which may be problematic in large application, but for small application it should be fine.
   
3. It’s using internal multi-threading technology which is comparatively slower than raw threading program.

Feeling interested ? ' Be right back with other articles for Socket programming.