Click here to Skip to main content
15,867,568 members
Articles / Programming Languages / C#
Article

A Chat Application Using Asynchronous UDP sockets

Rate me:
Please Sign up or sign in to vote.
4.86/5 (52 votes)
29 Dec 20064 min read 442.1K   27.8K   197   66
This article shows how to develop a chat application using UDP sockets.

Image 1

Introduction

In the previous article, I discussed a chat application using TCP sockets. In this part, I will show how to do it using UDP sockets.

Differences between UDP and TCP

TCP is connection oriented, and provides error and flow control. UDP provides no such services, and relies on the application layer for them. UDP allows sending a packet with or without checksum; no connection is maintained, so each packet is sent independently. If a packet gets lost or the packets arrive out of order, then the application should detect and remedy the situation on its own. Also, UDP doesn’t give the security features of TCP like the three-way handshake.

So what is in UDP that TCP doesn’t do? Firstly, UDP supports multicast – sending a single packet to multiple machines. This is useful as it saves bandwidth, each packet is transmitted only once and the entire network receives it. UDP is also used in places where the overhead (delay) involved with TCP is expensive.

Some applications of UDP are in VoIP, streaming of audio and video, DNS, TFTP, SNMP, online gaming, and etcetera.

Asynchronous UDP sockets

Asynchronous UDP sockets have a Begin and End appended to the standard socket functions, like BeginSendTo, BeginReceiveFrom, EndSendTo, and EndReceiveFrom. Let's take a look at one of them:

C#
IAsyncResult BeginReceiveFrom(byte[] buffer, int offset, int size,
 SocketFlags sockflag, ref EndPoint ep, AsyncCallback callback, object state)

The BeginReceiveFrom() method accepts data from any remote host on a connectionless socket. Notice that the BeginReceiveFrom() method is similar to the BeginReceive() method, except that it specifies a reference to an EndPoint object. The EndPoint object defines the remote host IP address and the port number that sent the data.

The AsyncCallback function is called when the function completes. Just as events can trigger delegates, .NET also provides a way for methods to trigger delegates. The .NET AsyncCallback class allows methods to start an asynchronous function and supply a delegate method to call when the asynchronous function completes.

The state object is used to pass information between the BeginAccept and the corresponding AsyncCallback function.

A sample BeginReceiveFrom() method would look like this:

C#
sock.BeginReceive(data, 0, data.Length, SocketFlags.None, 
                  ref iep, new AsyncCallback(ReceiveData), sock);

The corresponding EndReceiveFrom() method is placed in the appropriate AsyncCallback method:

C#
void ReceiveData(IasyncResult iar)
{
    Socket remote = (Socket)iar.AsyncState;
    int recv = remote.EndReceiveFrom(iar);
    string stringData = Encoding.ASCII.GetString(data, 0, recv);
    Console.WriteLine(stringData);
}

The EndReceiveFrom() method returns the number of bytes read from the socket, and places the received data in the data buffer defined in the BeginReceiveFrom() method. To access this data, the data buffer should be accessible from both the methods.

Getting Started

The architecture of the application using TCP sockets and the one using UDP sockets is very similar. Both applications use the same data structures to communicate between the server and the client.

For exchange of messages between the client and the server, both of them use the following trivial commands:

C#
//The commands for interaction between 
//the server and the client
enum Command
{
  //Log into the server
    Login,      
  //Logout of the server
    Logout,
  //Send a text message to all the chat clients     
    Message,    
  //Get a list of users in the chat room from the server
    List
}

The data structure used to exchange between the client and the server is shown below. Sockets transmit and receive data as an array of bytes, the overloaded constructor and the ToByte member function performs this conversion.

C#
//The data structure by which the server 
//and the client interact with each other
class Data
{
    //Default constructor
    public Data()
    {
        this.cmdCommand = Command.Null;
        this.strMessage = null;
        this.strName = null;
    }

    //Converts the bytes into an object of type Data
    public Data(byte[] data)
    {
        //The first four bytes are for the Command
        this.cmdCommand = (Command)BitConverter.ToInt32(data, 0);

        //The next four store the length of the name
        int nameLen = BitConverter.ToInt32(data, 4);

        //The next four store the length of the message
        int msgLen = BitConverter.ToInt32(data, 8);

        //Makes sure that strName has been 
        //passed in the array of bytes
        if (nameLen > 0)
            this.strName = 
              Encoding.UTF8.GetString(data, 12, nameLen);
        else
            this.strName = null;

        //This checks for a null message field
        if (msgLen > 0)
            this.strMessage = 
              Encoding.UTF8.GetString(data, 12 + nameLen, msgLen);
        else
            this.strMessage = null;
    }

    //Converts the Data structure into an array of bytes
    public byte[] ToByte()
    {
        List<byte> result = new List<byte>();

        //First four are for the Command
        result.AddRange(BitConverter.GetBytes((int)cmdCommand));

        //Add the length of the name
        if (strName != null)
            result.AddRange(BitConverter.GetBytes(strName.Length));
        else
            result.AddRange(BitConverter.GetBytes(0));

        //Length of the message
        if (strMessage != null)
            result.AddRange(
              BitConverter.GetBytes(strMessage.Length));
        else
            result.AddRange(BitConverter.GetBytes(0));

        //Add the name
        if (strName != null)
            result.AddRange(Encoding.UTF8.GetBytes(strName));

        //And, lastly we add the message 
        //text to our array of bytes
        if (strMessage != null)
            result.AddRange(Encoding.UTF8.GetBytes(strMessage));

        return result.ToArray();
    }

    //Name by which the client logs into the room
    public string strName;
    //Message text
    public string strMessage;
    //Command type (login, logout, send message, etc)
    public Command cmdCommand;
}

UDP Server

The following are some of the data members used by the server application:

C#
//The ClientInfo structure holds the 
//required information about every
//client connected to the server
struct ClientInfo
{
    //Socket of the client
    public EndPoint endpoint;
    //Name by which the user logged into the chat room
    public string strName;
}

//The collection of all clients logged into 
//the room (an array of type ClientInfo)
ArrayList clientList;

//The main socket on which the server listens to the clients
Socket serverSocket;

byte[] byteData = new byte[1024];

One important point to note here is that, in UDP, there is no such distinction between the client and server applications. Unlike TCP, UDP servers don’t listen for incoming clients; they just look for data coming from other clients. Once we receive data, we see if it’s a message for login, logout, etc.

C#
private void Form1_Load(object sender, EventArgs e)
{            
    try
    {
        //We are using UDP sockets
        serverSocket = new Socket(AddressFamily.InterNetwork, 
            SocketType.Dgram, ProtocolType.Udp);

        //Assign the any IP of the machine and listen on port number 1000
        IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, 1000);

        //Bind this address to the server
        serverSocket.Bind(ipeServer);
        
        IPEndPoint ipeSender = new IPEndPoint(IPAddress.Any, 0);
        //The epSender identifies the incoming clients
        EndPoint epSender = (EndPoint) ipeSender;

        //Start receiving data
        serverSocket.BeginReceiveFrom (byteData, 0, byteData.Length, 
            SocketFlags.None, ref epSender, 
               new AsyncCallback(OnReceive), epSender);
    }
    catch (Exception ex) 
    { 
        MessageBox.Show(ex.Message, "SGSServerUDP", 
            MessageBoxButtons.OK, MessageBoxIcon.Error); 
    }
}

With IPAddress.Any, we specify that the server should accept client requests coming on any interface. To use any particular interface, we can use IPAddress.Parse (“192.168.1.1”) instead of IPAddress.Any. The Bind function then bounds the serverSocket to this IP address. The epSender identifies the clients from where the data is coming.

With BeginReceiveFrom, we start receiving the data that will be sent by the client. Note that we pass epSender as the last parameter of BeginReceiveFrom, the AsyncCallback OnReceive gets this object via the AsyncState property of IAsyncResult, and it then processes the client requests (login, logout, and send message to the users). Please see the code attached to understand the implementation of OnReceive.

TCP Client

Some of the data members used by the client are:

C#
public Socket clientSocket; //The main client socket
public string strName;      //Name by which the user logs into the room
public EndPoint epServer;   //The EndPoint of the server

byte []byteData = new byte[1024];

The client firstly connects to the server:

C#
try
{
    //Using UDP sockets
    clientSocket = new Socket(AddressFamily.InterNetwork, 
        SocketType.Dgram, ProtocolType.Udp);

    //IP address of the server machine
    IPAddress ipAddress = IPAddress.Parse(txtServerIP.Text);
    //Server is listening on port 1000
    IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 1000);

    epServer = (EndPoint)ipEndPoint;
    
    Data msgToSend = new Data ();
    msgToSend.cmdCommand = Command.Login;
    msgToSend.strMessage = null;
    msgToSend.strName = strName;

    byte[] byteData = msgToSend.ToByte();
    
    //Login to the server
    clientSocket.BeginSendTo(byteData, 0, byteData.Length, 
        SocketFlags.None, epServer, 
        new AsyncCallback(OnSend), null);
}
catch (Exception ex)
{ 
    MessageBox.Show(ex.Message, "SGSclient", 
        MessageBoxButtons.OK, MessageBoxIcon.Error); 
}

The client after connecting to the server sends a login message. And, after that, we send a List message to get the names of clients in the chat room.

C#
//Broadcast the message typed by the user to everyone
private void btnSend_Click(object sender, EventArgs e)
{
    try
    {
        //Fill the info for the message to be send
        Data msgToSend = new Data();
        
        msgToSend.strName = strName;
        msgToSend.strMessage = txtMessage.Text;
        msgToSend.cmdCommand = Command.Message;

        byte[] byteData = msgToSend.ToByte();

        //Send it to the server
        clientSocket.BeginSendTo (byteData, 0, byteData.Length, 
            SocketFlags.None, epServer, 
            new AsyncCallback(OnSend), null);

        txtMessage.Text = null;
    }
    catch (Exception)
    {
        MessageBox.Show("Unable to send message to the server.", 
            "SGSclientUDP: " + strName, MessageBoxButtons.OK, 
            MessageBoxIcon.Error);
    }  
}

The message typed by the user is sent as a Command message to the server which then sends it to all other users in the chat room.

Upon receiving a message, the client processes it accordingly (depending on whether it’s a login, logout, command, or a list message). The code for this is fairly straightforward, kindly see the attached project.

Conclusion

As you would have noticed, the UDP chat application is not very different from the TCP one; in fact, converting the TCP one into UDP was less than a day's work for me. I hope you find these articles useful. Thank you.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here


Written By
United States United States
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.

Comments and Discussions

 
GeneralRe: Disconnecting and reconnecting with same nickname doesnt work! Pin
Steve3635-Sep-11 15:16
Steve3635-Sep-11 15:16 
GeneralRe: Disconnecting and reconnecting with same nickname doesnt work! Pin
Member 973023614-Jan-13 18:20
Member 973023614-Jan-13 18:20 
QuestionHow can you get this to work over the internet such as sending messages from one computer to another? Pin
codewizard5626-Mar-10 19:48
codewizard5626-Mar-10 19:48 
Questionif client listening to multiple multicast adr, how to detect receive msg from which multicast group Pin
Batul Saifee11-Mar-10 5:31
Batul Saifee11-Mar-10 5:31 
GeneralSniffer displays OICQ protocol Pin
triplebit15-Nov-09 23:26
triplebit15-Nov-09 23:26 
Generalthanx alot Pin
mr_sawari8-Oct-09 1:15
mr_sawari8-Oct-09 1:15 
GeneralQuestion Pin
Alireza_13627-Oct-09 12:34
Alireza_13627-Oct-09 12:34 
GeneralRe: Question Pin
zimmwarrior21-May-10 9:36
zimmwarrior21-May-10 9:36 
This function solves an Cross Thread Call exceptions.
It's like if you delete this line when the program will try to write something into a chatlog after recieving some data program will be aborted with an exception Illegal Thread Call because you are trying to access your chatlog "your textbox" from a thread which was actually created for main program thread.
I've actually had same problem with my own chat in C# well, I somehow thought on this one chat here and used this function in my chat so I got the cross thread calls exception gone. Smile | :)
Hope I could help!
Greets Andriy!
General[Message Deleted] Pin
it.ragester28-Mar-09 5:35
it.ragester28-Mar-09 5:35 
QuestionImplementation of Asynchronous operation in web application Pin
M. J. Jaya Chitra10-Mar-09 20:12
M. J. Jaya Chitra10-Mar-09 20:12 
GeneralUsing UDP, Socket.ReceiveFrom, BeginReceiveFrom/EndReceiveFrom Incorrectly report remote host disconnected condition Pin
Pradeep Manohar7-Jan-09 9:19
Pradeep Manohar7-Jan-09 9:19 
GeneralRe: Using UDP, Socket.ReceiveFrom, BeginReceiveFrom/EndReceiveFrom Incorrectly report remote host disconnected condition Pin
donperry23-Jun-09 15:51
donperry23-Jun-09 15:51 
QuestionHow To Send Data From Client To Server via Server Side ? Pin
Yefta8-Sep-08 23:47
Yefta8-Sep-08 23:47 
GeneralPerfect Pin
alejandro29A14-Aug-08 3:12
alejandro29A14-Aug-08 3:12 
QuestionSystem.Net.Sockets.SocketException: Only one usage of each socket address (protocol/network address/port) is normally permitted Pin
Member 407262230-Jul-08 4:09
Member 407262230-Jul-08 4:09 
GeneralHi Pin
ysudhakar5-May-08 1:51
ysudhakar5-May-08 1:51 
Generalplese help me Pin
irfanashrafali22-Apr-08 21:44
irfanashrafali22-Apr-08 21:44 
Generalproblem when receiver behind router Pin
hafidz11-Feb-08 21:47
hafidz11-Feb-08 21:47 
GeneralRe: problem when receiver behind router Pin
Hitesh Sharma12-Feb-08 0:54
Hitesh Sharma12-Feb-08 0:54 
AnswerSolve: Server stopped responding once a client exits Pin
imseven15-Dec-07 23:19
imseven15-Dec-07 23:19 
GeneralRe: Solve: Server stopped responding once a client exits Pin
Jacob Dixon27-Apr-09 7:54
Jacob Dixon27-Apr-09 7:54 
Questionneed references its a little bit urgent Pin
mallikan28-Sep-07 4:51
mallikan28-Sep-07 4:51 
QuestionPlease help me! Pin
c_student18-Aug-07 11:57
c_student18-Aug-07 11:57 
AnswerRe: Please help me! Pin
Jay Gatsby18-Aug-07 13:37
Jay Gatsby18-Aug-07 13:37 
Questionhow to develop web chatting with c# Pin
shawn41422-Feb-07 9:55
shawn41422-Feb-07 9:55 

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

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