Click here to Skip to main content
Click here to Skip to main content

How To Use the SocketAsyncEventArgs Class

, 29 Sep 2010 CPOL
Rate this:
Please Sign up or sign in to vote.
An article about how to use the SocketAsyncEventArgs class

Introduction

I was looking for a high performance code for a client socket. Previously, I wrote a code based on the traditional asynchronous programming model methods from the Socket class (BeginSend, BeginReceive, and so on). But it didn't fill the performance requirements I needed. Then, I found the new model for event-based asynchronous operations (see "Get Connected with the .NET Framework 3.5" in the September 2007 issue of the MSDN Magazine).

Background

The Asynchronous Programming Model (APM) is used widely in I/O-bound applications to achieve high performance, due to the reduction of blocking threads. APM is implemented in the .NET Framework since its first version, and is improving since then, using new techniques like lambda expressions from C# 3.0. Specifically for socket programming, the new model for APM delivers an easier coding, not to mention the performance benefits. It is done towards the use of the SocketAsyncEventArgs class to keep the context between I/O operations, which reduces object allocation and the garbage collection working.

The SocketAsyncEventArgs class is also available in the .NET Framework 2.0 SP1, and the code from this article was written using Microsoft Visual Studio .NET 2008.

Using the Code

To begin with the SocketAsyncEventArgs class, I studied the example from MSDN, but there was something missing: the AsyncUserToken class. I understood the class should expose a property Socket, corresponding to the socket used to perform the I/O operations. But how to keep data received from client until the accept operation ends? Since UserToken is an Object, it could accept anything, so I created a Token class to track the accept operation. Below shown are the modified methods to use the instance of Token class as the UserToken.

// Process the accept for the socket listener.
private void ProcessAccept(SocketAsyncEventArgs e)
{
    Socket s = e.AcceptSocket;
    if (s.Connected)
    {
        try
        {
            SocketAsyncEventArgs readEventArgs = this.readWritePool.Pop();
            if (readEventArgs != null)
            {
                // Get the socket for the accepted client connection and put it into the 
                // ReadEventArg object user token.
                readEventArgs.UserToken = new Token(s, this.bufferSize);

                Interlocked.Increment(ref this.numConnectedSockets);
                Console.WriteLine("Client connection accepted. 
			There are {0} clients connected to the server",
                    this.numConnectedSockets);

                if (!s.ReceiveAsync(readEventArgs))
                {
                    this.ProcessReceive(readEventArgs);
                }
            }
            else
            {
                Console.WriteLine("There are no more available sockets to allocate.");
            }
        }
        catch (SocketException ex)
        {
            Token token = e.UserToken as Token;
            Console.WriteLine("Error when processing data received from {0}:\r\n{1}", 
			token.Connection.RemoteEndPoint, ex.ToString());
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }

        // Accept the next connection request.
        this.StartAccept(e);
    }
}

// This method is invoked when an asynchronous receive operation completes. 
// If the remote host closed the connection, then the socket is closed.
// If data was received then the data is echoed back to the client.
private void ProcessReceive(SocketAsyncEventArgs e)
{
    // Check if the remote host closed the connection.
    if (e.BytesTransferred > 0)
    {
        if (e.SocketError == SocketError.Success)
        {
            Token token = e.UserToken as Token;
            token.SetData(e);

            Socket s = token.Connection;
            if (s.Available == 0)
            {
                // Set return buffer.
                token.ProcessData(e);
                if (!s.SendAsync(e))
                {
                    // Set the buffer to send back to the client.
                    this.ProcessSend(e);
                }
            }
            else if (!s.ReceiveAsync(e))
            {
                // Read the next block of data sent by client.
                this.ProcessReceive(e);
            }
        }
        else
        {
            this.ProcessError(e);
        }
    }
    else
    {
        this.CloseClientSocket(e);
    }
}

// This method is invoked when an asynchronous send operation completes.
// The method issues another receive on the socket to read any additional 
// data sent from the client.
private void ProcessSend(SocketAsyncEventArgs e)
{
    if (e.SocketError == SocketError.Success)
    {
        // Done echoing data back to the client.
        Token token = e.UserToken as Token;
        if (!token.Connection.ReceiveAsync(e))
        {
            // Read the next block of data send from the client.
            this.ProcessReceive(e);
        }
    }
    else
    {
        this.ProcessError(e);
    }
}

I also modified the code to show where you can manipulate the message received by the listener. In the example, I created the method ProcessData in the Token class to echoing back to the client the received message.

To control the listener lifetime, an instance of the Mutex class is used. The Start method, which is based on the original Init method creates the mutex, and the corresponding Stop method releases the mutex. These methods are suitable to implement the socket server as a Windows Service.

// Starts the server such that it is listening
// for incoming connection requests.
internal void Start(Int32 port)
{
    // Get host related information.
    IPAddress[] addressList = 
          Dns.GetHostEntry(Environment.MachineName).AddressList;
    // Get endpoint for the listener.
    IPEndPoint localEndPoint = 
          new IPEndPoint(addressList[addressList.Length - 1], port);

    // Create the socket which listens for incoming connections.
    this.listenSocket = new Socket(localEndPoint.AddressFamily, 
                        SocketType.Stream, ProtocolType.Tcp);

    if (localEndPoint.AddressFamily == AddressFamily.InterNetworkV6)
    {
        // Set dual-mode (IPv4 & IPv6) for the socket listener.
        // 27 is equivalent to IPV6_V6ONLY socket
        // option in the winsock snippet below,
        // based on http://blogs.msdn.com/wndp/archive/2006/10/24/
        //   creating-ip-agnostic-applications-part-2-dual-mode-sockets.aspx
        this.listenSocket.SetSocketOption(SocketOptionLevel.IPv6, 
                                         (SocketOptionName)27, false);
        this.listenSocket.Bind(new IPEndPoint(IPAddress.IPv6Any, 
                               localEndPoint.Port));
    }
    else
    {
        // Associate the socket with the local endpoint.
        this.listenSocket.Bind(localEndPoint);
    }

    // Start the server.
    this.listenSocket.Listen(this.numConnections);

    // Post accepts on the listening socket.
    this.StartAccept(null);

    mutex.WaitOne();
}

// Stop the server.
internal void Stop()
{
    mutex.ReleaseMutex();
}

Now that we have a socket server, the next step is to create a socket client using the SocketAsyncEventArgs class. Although the MSDN says that the class is specifically designed for network server applications, there is no restriction in using this APM in a client code. Below, there is the SocketClien class, written in this way:

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

namespace SocketAsyncClient
{
    // Implements the connection logic for the socket client.
    internal sealed class SocketClient : IDisposable
    {
        // Constants for socket operations.
        private const Int32 ReceiveOperation = 1, SendOperation = 0;

        // The socket used to send/receive messages.
        private Socket clientSocket;

        // Flag for connected socket.
        private Boolean connected = false;

        // Listener endpoint.
        private IPEndPoint hostEndPoint;

        // Signals a connection.
        private static AutoResetEvent autoConnectEvent = 
                              new AutoResetEvent(false); 

        // Signals the send/receive operation.
        private static AutoResetEvent[] 
                autoSendReceiveEvents = new AutoResetEvent[]
        {
            new AutoResetEvent(false),
            new AutoResetEvent(false)
        };

        // Create an uninitialized client instance.
        // To start the send/receive processing call the
        // Connect method followed by SendReceive method.
        internal SocketClient(String hostName, Int32 port)
        {
            // Get host related information.
            IPHostEntry host = Dns.GetHostEntry(hostName);

            // Address of the host.
            IPAddress[] addressList = host.AddressList;

            // Instantiates the endpoint and socket.
            hostEndPoint = 
              new IPEndPoint(addressList[addressList.Length - 1], port);
            clientSocket = new Socket(hostEndPoint.AddressFamily, 
                               SocketType.Stream, ProtocolType.Tcp);
        }

        // Connect to the host.
        internal void Connect()
        {
            SocketAsyncEventArgs connectArgs = new SocketAsyncEventArgs();

            connectArgs.UserToken = clientSocket;
            connectArgs.RemoteEndPoint = hostEndPoint;
            connectArgs.Completed += 
               new EventHandler<socketasynceventargs />(OnConnect);

            clientSocket.ConnectAsync(connectArgs);
            autoConnectEvent.WaitOne();

            SocketError errorCode = connectArgs.SocketError;
            if (errorCode != SocketError.Success)
            {
                throw new SocketException((Int32)errorCode);
            }
        }

        /// Disconnect from the host.
        internal void Disconnect()
        {
            clientSocket.Disconnect(false);
        }

        // Calback for connect operation
        private void OnConnect(object sender, SocketAsyncEventArgs e)
        {
            // Signals the end of connection.
            autoConnectEvent.Set();

            // Set the flag for socket connected.
            connected = (e.SocketError == SocketError.Success);
        }

        // Calback for receive operation
        private void OnReceive(object sender, SocketAsyncEventArgs e)
        {
            // Signals the end of receive.
            autoSendReceiveEvents[SendOperation].Set();
        }

        // Calback for send operation
        private void OnSend(object sender, SocketAsyncEventArgs e)
        {
            // Signals the end of send.
            autoSendReceiveEvents[ReceiveOperation].Set();

            if (e.SocketError == SocketError.Success)
            {
                if (e.LastOperation == SocketAsyncOperation.Send)
                {
                    // Prepare receiving.
                    Socket s = e.UserToken as Socket;

                    byte[] receiveBuffer = new byte[255];
                    e.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);
                    e.Completed += 
                      new EventHandler<socketasynceventargs />(OnReceive);
                    s.ReceiveAsync(e);
                }
            }
            else
            {
                ProcessError(e);
            }
        }

        // Close socket in case of failure and throws
        // a SockeException according to the SocketError.
        private void ProcessError(SocketAsyncEventArgs e)
        {
            Socket s = e.UserToken as Socket;
            if (s.Connected)
            {
                // close the socket associated with the client
                try
                {
                    s.Shutdown(SocketShutdown.Both);
                }
                catch (Exception)
                {
                    // throws if client process has already closed
                }
                finally
                {
                    if (s.Connected)
                    {
                        s.Close();
                    }
                }
            }

            // Throw the SocketException
            throw new SocketException((Int32)e.SocketError);
        }

        // Exchange a message with the host.
        internal String SendReceive(String message)
        {
            if (connected)
            {
                // Create a buffer to send.
                Byte[] sendBuffer = Encoding.ASCII.GetBytes(message);

                // Prepare arguments for send/receive operation.
                SocketAsyncEventArgs completeArgs = new SocketAsyncEventArgs();
                completeArgs.SetBuffer(sendBuffer, 0, sendBuffer.Length);
                completeArgs.UserToken = clientSocket;
                completeArgs.RemoteEndPoint = hostEndPoint;
                completeArgs.Completed += 
                  new EventHandler<socketasynceventargs />(OnSend);

                // Start sending asynchronously.
                clientSocket.SendAsync(completeArgs);

                // Wait for the send/receive completed.
                AutoResetEvent.WaitAll(autoSendReceiveEvents);

                // Return data from SocketAsyncEventArgs buffer.
                return Encoding.ASCII.GetString(completeArgs.Buffer, 
                       completeArgs.Offset, completeArgs.BytesTransferred);
            }
            else
            {
                throw new SocketException((Int32)SocketError.NotConnected);
            }
        }

        #region IDisposable Members

        // Disposes the instance of SocketClient.
        public void Dispose()
        {
            autoConnectEvent.Close();
            autoSendReceiveEvents[SendOperation].Close();
            autoSendReceiveEvents[ReceiveOperation].Close();
            if (clientSocket.Connected)
            {
                clientSocket.Close();
            }
        }

        #endregion
    }
}

Points of Interest

I had an experience with a socket server running in a clustered environment. In this scenario, you can't use the first entry in the address list from the host. Instead, you should use the last address, as shown in the Start method. Another technique presented here is how to set the dual mode for an IP6 address family, which is helpful if you want to run the server in a Windows Vista or Windows Server 2008, which enables IP6 by default.

Both programs use command-line arguments to run. In the client example, you should inform "localhost" as the name of the host instead of the machine name if both the server and the client are running in a machine out of a Windows domain.

History

  • 15 January, 2008 - Original version posted
  • 28 September, 2010 - Updated article and server example

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Marcos Hidalgo Nunes
Architect
Brazil Brazil
I am working with software development since 1989, mainly in distributed environments.

Comments and Discussions

 
QuestionHow to keep the access request to the server by the client when server program is terminated abruptly? PinmemberMember 1107355025-Sep-14 23:04 
QuestionToken.ProcessData can't read all the bytes from client. PinmemberMember 1073872910-Apr-14 0:21 
GeneralMy vote of 5 Pinmemberforgetyouyou17-Jul-13 4:23 
GeneralMy vote of 5 Pinmemberreachen13-Apr-13 7:17 
QuestionCompleting Data Sent and Timeout [modified] PinmemberWendell M.4-Jan-13 20:55 
Hi Marcos,
 
thanks for sharing a very useful code and information. I tried to implement the class (server app) and created a client application that connects to the server with the code you shared, however, running multiple clients (3 client apps during testing) and each client app was sending message simultaneously (I was looping 1,000 times for each app to send message with Thread.sleep(3000)) and at some point all 3 got disconnected and the client outputs this exception and sometimes the server app crashes:
 
<pre>System.Net.Sockets.SocketException (0x80004005): A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond
   at System.Net.Sockets.Socket.Receive(Byte[] buffer, Int32 offset, Int32 size, SocketFlags socketFlags)
   at System.Net.Sockets.Socket.Receive(Byte[] buffer)
 
Another thing that I have observed as well was when I tried to lowered down the buffer size just to test if the complete message will be received by the server, the server did not receive the entire message it just retried 2 times and stops without completing the entire content payload.
 
Any thoughts?
 
Thank you once again for your time.

modified 5-Jan-13 2:08am.

QuestionVery good PinmemberLuiz Salamon10-Dec-12 1:27 
AnswerRe: Very good PinmemberMarcos Hidalgo Nunes10-Dec-12 14:26 
QuestionMemory leak Pinmemberkorrea805-Sep-12 7:04 
AnswerRe: Memory leak PinmemberMarcos Hidalgo Nunes5-Sep-12 15:23 
GeneralRe: Memory leak Pinmemberkorrea805-Sep-12 22:36 
GeneralRe: Memory leak PinmemberMarcos Hidalgo Nunes11-Sep-12 15:52 
GeneralRe: Memory leak [modified] PinmemberBukan iJam8-Feb-14 23:20 
GeneralRe: Memory leak [modified] PinmemberMarcos Hidalgo Nunes10-Feb-14 13:33 
GeneralRe: Memory leak PinmemberBukan iJam12-Feb-14 0:51 
QuestionSending data without receiving? Pinmembernickelm3-Sep-12 0:53 
AnswerRe: Sending data without receiving? PinmemberMarcos Hidalgo Nunes3-Sep-12 14:54 
GeneralRe: Sending data without receiving? Pinmembernickelm3-Sep-12 23:36 
GeneralRe: Sending data without receiving? PinmemberMarcos Hidalgo Nunes4-Sep-12 15:53 
GeneralRe: Sending data without receiving? Pinmembernickelm4-Sep-12 20:00 
Questionhow to code a server base on SocketAsyncEventAgrs Echo multiple clients? Pinmemberlvyuqiang29-May-12 0:57 
AnswerRe: how to code a server base on SocketAsyncEventAgrs Echo multiple clients? PinmemberMarcos Hidalgo Nunes29-May-12 17:41 
GeneralRe: how to code a server base on SocketAsyncEventAgrs Echo multiple clients? Pinmemberlvyuqiang29-May-12 18:54 
GeneralRe: how to code a server base on SocketAsyncEventAgrs Echo multiple clients? PinmemberMarcos Hidalgo Nunes5-Jun-12 16:02 
GeneralRe: how to code a server base on SocketAsyncEventAgrs Echo multiple clients? Pinmemberlvyuqiang12-Jun-12 19:05 
QuestionIs this still the best approach? PinmemberPaul Tait6-Oct-11 16:03 
GeneralI have one question PinmemberMember 78137425-Apr-11 5:16 
GeneralRe: I have one question PinmemberMarcos Hidalgo Nunes5-Apr-11 18:00 
GeneralRe: I have one question PinmemberMember 78137425-Apr-11 23:27 
GeneralRe: I have one question PinmemberMarcos Hidalgo Nunes7-Apr-11 14:53 
GeneralCrash after 1300 connections PinmemberDJAlexxstyle21-Mar-11 9:06 
GeneralRe: Crash after 1300 connections PinmemberMarcos Hidalgo Nunes21-Mar-11 15:26 
GeneralRe: Crash after 1300 connections [modified] PinmemberDJAlexxstyle22-Mar-11 10:52 
GeneralRe: Crash after 1300 connections [modified] Pinmembermeraydin6-May-12 21:47 
GeneralMy vote of 5 PinmemberSteveWilkinson21-Dec-10 23:30 
QuestionSSL with SocketAsyncEventArgs? Pinmemberjcexited6-Oct-10 21:55 
AnswerRe: SSL with SocketAsyncEventArgs? PinmemberMarcos Hidalgo Nunes7-Oct-10 17:14 
GeneralRe: SSL with SocketAsyncEventArgs? PinmemberMetal_GOD13-Dec-10 7:57 
GeneralRe: SSL with SocketAsyncEventArgs? PinmemberMarcos Hidalgo Nunes13-Dec-10 15:31 
GeneralWhere to Process the incoming message and respond indepenently for each client Pinmembernickvh6-Oct-10 7:52 
GeneralRe: Where to Process the incoming message and respond indepenently for each client PinmemberMarcos Hidalgo Nunes7-Oct-10 17:25 
Generaliocp socket server PinmemberVF8-Sep-10 23:43 
GeneralRe: iocp socket server PinmemberTheBigDirty27-Feb-11 16:50 
GeneralRe: iocp socket server PinmemberVF28-Feb-11 0:29 
QuestionHow to handle packet split? PinmemberMarinDaniel26-Jun-10 0:51 
AnswerRe: How to handle packet split? PinmemberMarinDaniel27-Jun-10 1:09 
GeneralRe: How to handle packet split? PinmemberStan Kirk19-Aug-10 17:30 
GeneralRe: How to handle packet split? PinmemberMarcos Hidalgo Nunes30-Sep-10 17:15 
QuestionGood article, but what's the point? PinmemberVladimir Zelenko22-Jun-10 4:43 
AnswerRe: Good article, but what's the point? PinmemberEric Hileman27-Feb-11 16:20 
GeneralRe: Good article, but what's the point? PinmemberVladimir Zelenko27-Feb-11 16:36 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.141223.1 | Last Updated 29 Sep 2010
Article Copyright 2008 by Marcos Hidalgo Nunes
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid