Asynchronous Socket Communications Using the .NET Framework

The storage location for the received data.

The zero-based position in the buffer parameter, at which to store the received data.

The number of bytes to receive.

A bitwise combination of the SocketFlags values.

The AsyncCallback delegate.

An object containing state information for this request.

The AsyncCallback delegate deserves a little attention. This is where we will implement our data processing, as the BeginXXX methods initiate the asynchronous operation only. We must supply a delegate function to process the results from the asynchronous operation. Below is an example of using an AsynchCallback delegate function.

private void AsynchReadCallback(IAsyncResult ar)
{
    SocketStateObject so = (SocketStateObject)ar.AsyncState;
    Socket s = so.WorkSocket;

    try
    {
        // sanity check
        if (s == null || !s.Connected) return;

        // call EndRecieve which will return the number of bytes read
        int read = s.EndReceive(ar);
        if (read > 0)
        {
            // get the buffer as a string
            string msg = Encoding.ASCII.GetString(so.buffer, 0, read);
            if (OnReceive != null)
            {
                // call delegate to inform client
                OnReceive(_myID, msg);
            }

            // and start receiving more
            s.BeginReceive(so.buffer,
                    0, SocketStateObject.BUFFER_SIZE, 0,
                    new AsyncCallback(AsynchReadCallback), so);
        }
    }
    catch {}
}

public void AsynchSendCallback(System.IAsyncResult ar)
{
    SocketStateObject so = (SocketStateObject)ar.AsyncState;
    Socket s = so.WorkSocket;

    try
    {
        // sanity check
        if (s == null || !s.Connected) return;
        int send = s.EndSend(ar);
    }
    catch {}
}

The code above first obtains the user defined object using the AsynchState property of the ar parameter. The Socket stored in the state object is obtained and the EndRecieve method is called on the socket. The receive processing function will loop until there are no more bytes to read, at which point, it re-enters the main loop. While data is left to receive, the receive handler will continue to call BeginRecieve. The send function is much simpler, it will just call EndSend and terminate. It's important to note that EndRecieve and EndSend will most likely block.

Let's start looking at the required interface for a bare-bones socket manager. We obviously need Send and Receive methods. Let's look at those now. Below is an example of a public Send method.

public void SendMessage(string Message)
{
    // queue it...
    TransmitLock.AcquireWriterLock(-1);
    try
    {
        TransmitQueue.Enqueue(Message);
    }
    catch {}
    finally { TransmitLock.ReleaseWriterLock(); }

    // signal that data was sent
    DataReady.Set();
}

The code above begins, by using a critical section object to provide thread safety. The message is then added to the transmit queue, and the critical section object is released. Finally, the DataReady event is raised which is an AutoResetEvent object used to inform the send thread, that data is ready to be processed.

The next public method we need is a Connect method. Please see below for an example.

public int Connect(string hostName, int serviceport)
{
    //no need to do anything once connected
    if (_isConnected) return -1;

    // resolve...
    IPHostEntry hostEntry = Dns.Resolve(hostName);
    if ( hostEntry != null )
    {
        // create an end-point for the first address...
        IPEndPoint endPoint = new 
               IPEndPoint(hostEntry.AddressList[0], serviceport);

        // connect to host described by endpoint
        _socket.Connect(endPoint); OnConnect(_myID, true);

        // spin up the threads...
        //add the two threads for Receive and transmit
        ThreadPool.QueueUserWorkItem
                (new WaitCallback(ReceiveThreadEntryPoint));
        ThreadPool.QueueUserWorkItem
                (new WaitCallback(SendThreadEntryPoint));

        // set connected flag
        _isConnected = true;

        // return this unique id
        return _myID;
    }
    else
    {
        return -1;
    }
}

The code above combines two snippets we have already seen, for connecting a Socket and adding threads to the ThreadPool. The Disconnect method is shown below.

public void Disconnect()
{
    if (_isConnected)
    {
        _isConnected = false;

        // signal the threads to end
        StopEvent.Set();

        // now kill the socket
        if (_socket != null)
        {
            _socket.Close();
        }
        _socket = null;
    }
}

The code above uses a ManualResetEvent object, StopEvent, to signal the worker threads to terminate their loop.

Let's start looking at some implementation details. We will begin with the send and receive threads that are executed from the thread pool. Please see below for code examples.

public void ReceiveThreadEntryPoint(object state)
{
    try
    {
        // loop forever...
        while( true )
        {
            WaitHandle[] handles = new WaitHandle[1];
            handles[0] = StopEvent;

            if ( _socket != null && _socket.Connected )
            {
                // not disconnected
                try
                {
                    // start the receive operation
                    System.IAsyncResult iar;
                    SocketStateObject so2 = new SocketStateObject(_socket);
                    iar = _socket.BeginReceive(so2.buffer,
                            0, SocketStateObject.BUFFER_SIZE, 0,
                            new AsyncCallback(AsynchReadCallback), so2);

                    if( WaitHandle.WaitAny(handles) == 0 )
                    {
                        // stop event was signaled, break out of loop
                        break;
                    }
                }
                catch {}
            }
        }
    }
    catch {}
}

public void SendThreadEntryPoint(object state)
{
    try
    {
        Queue workQueue = new Queue();

        // loop...
        while( true )
        {
            WaitHandle[] handles = new WaitHandle[2];
            handles[0] = StopEvent;
            handles[1] = DataReady;

            if( WaitHandle.WaitAny(handles) == 0 )
            {
                // if the stop event was signalled, time to exit the loop
                break;
            }
            else if (_socket != null && _socket.Connected)
            {
                // not disconnected
                // go through the queue...
                TransmitLock.AcquireWriterLock(-1);
                try
                {
                    workQueue.Clear();
                    foreach( string message in _transmitQueue)
                    {
                        workQueue.Enqueue(message);
                    }
                    TransmitQueue.Clear();
                }
                catch {}
                finally
                {
                    TransmitLock.ReleaseWriterLock();
                }

                // loop the outbound messages...
                foreach( string message in workQueue )
                {
                    SocketStateObject so2 = new SocketStateObject(_socket);
                    byte[] buff = Encoding.ASCII.GetBytes(message);

                    // send it...
                    System.IAsyncResult iar;
                    iar = _socket.BeginSend(buff,
                            0, buff.Length, 0,
                            new AsyncCallback(AsynchSendCallback), so2);
                }
            }
        }
    }
    catch {}
}

The above illustrates the most complicated code in the entire AsynchSocketManager class. You will see, however, that it is easy to understand after analyzing the previous snippets. The first function is the thread pool managed receive thread. This function loops until a StopEvent is raised, which signifies that a disconnect message was received. If the StopEvent is not raised, the receive thread function calls BeginRecieve. This call will block until data is ready to be received which will be handled by the asynchronous callback AsynchReadCallback which was covered previously. The next function is the send thread function managed by the thread pool. This function loops until either the StopEvent or the DataReady event is raised. If StopEvent is raised the function exits, signifying a disconnect. If DataReady raises, the function will then remove all items currently in the TransmitQueue and add them to workQueue, which are then sent, one at a time, via the asynchronous BeginSend call.

Points of interest

Asynchronous socket I/O can be straight-forward, but proper thread safety and synchronization is essential. The ThreadPool object helps manage some of the headaches with terminating threads, especially if the destructor is not called - which can happen if the main thread is terminated unexpectedly. This can leave threads running or in an indeterminate state. The ThreadPool insulates us from that, when we allow it to manage our threads. In my next article I will discuss, using .NET socket classes in a ThreadPool managed socket server, using I/O completion ports.