The UdpClient Class

The UdpClient Class Constructors

The UdpClient class has four formats of constructors:

UdpClient() This format creates a new UdpClient instance not bound to any specific address or port.

UdpClient(int port) This constructor binds the new UdpClient object to a specific UDP port number.

UdpClient(IPEndPoint iep) This constructor binds the new UdpClient object to a specific local IP address and port number.

UdpClient(string host, int port) This format binds the new UdpClient object to any local IP address and port and associates it with a specific remote IP address and port.

The UdpClient constructors work like their comparable TcpClient constructors. You can either let the system choose a UDP port for the application, or you can select a specific port in the constructor. If your UDP application must accept data on a specific port, you must define that port in the UdpClient constructor.

Once the UdpClient object is created, you can manipulate the underlying socket and move data using the various methods available.

The UdpClient Class Methods

The methods of the UdpClient class provide various functionality for controlling and moving data into and out of the UDP socket. Figure describes these methods.

Using the UdpClient Class in Programs

There are a few subtle differences between the UdpClient class’s Receive() and Send() methods that make them different from the Socket methods ReceiveFrom() and SendTo().

byte[] Receive(ref IPEndPoint iep)

IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 9050);
UdpClient newsock = new UdpClient(ipep);
byte[] data = new byte[1024];
IPEndPoint ipep2 = new IPEndPoint(IPAddress.Any, 0);
data = host.Receive(ref ipep2);
Console.WriteLine("The remote host is: {0}, port {1}",
  ipep2.Address, ipep2.Port);
Console.WriteLine(Encoding.ASCII.GetString(data));

UdpClient host = new UdpClient("127.0.0.1", 9050);

A Simple UdpClient Server Program

The UdpSrvrSample.cs program, shown in Listing 7.3, demonstrates using the UdpClient class methods in a server application environment.

Listing 7.3: The UdpSrvrSample.cs program

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
class UdpSrvrSample
{
  public static void Main()
  {
   byte[] data = new byte[1024];
   IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 9050);
   UdpClient newsock = new UdpClient(ipep);
   Console.WriteLine("Waiting for a client...");
   IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
   data = newsock.Receive(ref sender);
   Console.WriteLine("Message received from {0}:", sender.ToString());
   Console.WriteLine(Encoding.ASCII.GetString(data, 0, data.Length));
   string welcome = "Welcome to my test server";
   data = Encoding.ASCII.GetBytes(welcome);
   newsock.Send(data, data.Length, sender);
   while(true)
   {
     data = newsock.Receive(ref sender);
   
     Console.WriteLine(Encoding.ASCII.GetString(data, 0, data.Length));
     newsock.Send(data, data.Length, sender);
   }
  }
}

The UdpSrvrSample program creates a UdpClient object from an IPEndPoint object, specifying any IP address on the server and using UDP port 9050. The program immediately waits for an incoming UDP packet from any remote client, using the Receive() method:

IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
data = newsock.Receive(ref sender);

The sender variable stores the IP information of the client, which is then used for sending messages back to the client:

newsock.Send(data, data.Length, sender);

Because the UdpClient object does not know the IP information of the destination host, you must specify it for each Send() method call.

A Simple UdpClient Client Program

Here is the matching client program, UdpClientSample.cs (Listing 7.4), demonstrating how to use the UdpClient class methods in a UDP client application.

Listing 7.4: The UdpClientSample.cs program

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
class UdpClientSample
{
  public static void Main()
  {
   byte[] data = new byte[1024];
   string input, stringData;
   UdpClient server = new UdpClient("127.0.0.1", 9050);
   IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
   string welcome = "Hello, are you there?";
   data = Encoding.ASCII.GetBytes(welcome);
   server.Send(data, data.Length);
   data = server.Receive(ref sender);
   Console.WriteLine("Message received from {0}:", sender.ToString());
   stringData = Encoding.ASCII.GetString(data, 0, data.Length);
   Console.WriteLine(stringData);
   while(true)
   {
     input = Console.ReadLine();
     if (input == "exit")
      break;
   
     server.Send(Encoding.ASCII.GetBytes(input), input.Length);
     data = server.Receive(ref sender);
     stringData = Encoding.ASCII.GetString(data, 0, data.Length);
     Console.WriteLine(stringData);
   }
   Console.WriteLine("Stopping client");
   server.Close();
  }
}

Because the UdpClientSample program does not need to listen to a specific UDP port for incoming messages, you can use the all-in-one constructor format, specifying the IP address and UDP port number of the remote host:

UdpClient server = new UdpClient("127.0.0.1", 9050);

Of course, if you are connecting to a remote UDP server, remember to place either the IP address or hostname of the remote server in the constructor instead of the loopback address.

After the UdpClient object is created, the Send() method sends the greeting message out to the server:

server.Send(data, data.Length);

Notice that because the destination host address information was already specified in the UdpClient constructor, you do not need to specify it in the Send() method.

Testing the Sample Programs

After compiling the UdpSrvrSample and UdpClientSample programs, you can test them on the same machine or on separate machines on the network.

The output looks exactly like the output from the SimpleUdpClient program (Listing 6.2) shown in Chapter 6, "Connectionless Sockets." Each message sent using the Send() method call is sent as a single UDP packet to the remote machine and read using a single Receive() method call.

Because the UdpClient class employs UDP packets to transmit messages, it suffers from one of the same problems as the UDP Socket objects, as described in Chapter 6. Specifically, there is always the possibility that sent messages will not make it to the destination device, so you must compensate for that in your UdpClient programs. This is usually accomplished by using the retry techniques demonstrated in Chapter 6.