UDP Socket Programming For Distributed Computing in C#.Net

1. We’re going to create a console application project in Visual Studio, let’s do it

2. I’ll name it UdemyUDPBroadcastSender

3. In order to write UDP socket based programs

4. We need to include following namespaces

5. Let’s add these to the program

6. using System.Net;

7. using System.Net.Sockets;

8. Let’s add these to the program

9. We are going to use two objects from these namespaces

10. A Socket object

11. And an object of IPEndPoint, which is actually a pair of an IP Address and a port number

12. To practically broadcast the data, we are going to use the method Socket.SendTo

13. Let’s take a look at the MSDN page of this method

14. We’re going to use the first method which takes an array of bytes and the IP End Point of the client to which the data will be sent

15. Any data that we need to send through a socket over the network must be converted into byte format.

16. We’ll also define a byte array in our program.

17. We’ll see how that works later in this course.

18. Let’s move on to the next video and pump some code

1. I’ll opened the project which we created in last video

2. I’ll go to the main method

3. Create an object of Socket, I’ll call it sockBroadcaster

4. And new it up

5. We’ll use the constructor that takes three parameters.

6. Socket sockBroadcaster = new Socket(

7.                AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

   
   

8. The first parameter AddressFamily.InterNetwork means that we’ll be using IP V4.

9. Second parameter means we’ll be sending datagram and third parameter means we’ll be using UDP protocol.

10. We need to set the flag “EnableBroadcast” to true since we’ll be using this socket object to send a broadcast.

11. Next, we’ll create an object of IPEndPoint and name it broadcastEP.

12. To new this one up I’ll use the constructor that takes two parameters.

13. The first parameter is the IP Address.

14. In order to send a broadcast, we will set all values of IP address part of datagram to 1.

15. That is achieved by using 255.255.255.255

16. But, the constructor takes an IP Address, that means we can’t just throw a string in there.

17. Converting a string into an IP Address is very easy

18. We’re going to call static method IPAddress.Parse and pass it the string containing IP Address.

19. If the string will contain anything other than an IP Address, an exception will be thrown.

20. We can use the method IPAddress.TryParse, but right now we know we’re passing in a valid IP address so don’t worry.

21. The second parameter will be the port number on which we want to send the broadcast.

22. IPEndPoint broadcastEP = new IPEndPoint(IPAddress.Parse("255.255.255.255"),

23.                23000);

24. 
    

25. After that, let’s define an array to contain the data we want to broadcast.

26. byte[] bcBuffer =   new byte [] { 0x0D, 0x0A};

27. Now we’re going to call the method Socket.SendTo

28. But, let’s bring in a try/catch block before doing that.

29. 
    

30.    

31. Now the method call

32.                sockBroadcaster.SendTo(bcBuffer, broadcastEP);

33. We’ve passed it the byte array which contains our data and the endpoint where we want the broadcast data to go.

34. Once we’re done with the send operation, we’ll simply shut down the sender socket and then close it.

35. sockBroadcaster.Shutdown(SocketShutdown.Both);

36.                sockBroadcaster.Close();

37. The shutdown method call is going to disable operations on this socket object. Possible values are, send/receive and both.

38. After disabling communication, we’re going to call the close method which will free any resources associated with this socket object.

39. We now have a tiny piece of software which can send a broadcast over the network.

40. But the important questions is, who’s going to receive the broadcast?

41. In the next video, we’re going to write code for just that.

1. We’re going to create a console application for the purpose of receiving data on a UDP socket.

2. Let’s create a console application, I’ll name it UdemyUDPBroadcastReceiver.

3. First things first, we’ll add the relevant namespaces.

4. using System.Net;

5. using System.Net.Sockets;

6. Next, we’re going to go to the main method and create an object of Socket class just like we did it in the previous video.

7. 
   

8. If you didn’t see the last video, please watch it. I’ve explained this line of code there.

9. Next, we’re going to create an IP Endpoint and specify a pair of IP Address  and port number on which we’ll receive the data.

10.            

11. Let me explain the parameters

12. The first parameter means that this socket is going to receive data on all available IP addresses of this host.

13. A machine might have more than one network interface cards, or software defined IP addresses.

14. The second parameter means that this socket will receive data on port number 23000.

15. If you look at the UDP sender code which we wrote earlier, you’ll see that the sender is sending a broadcast to port number 23000.

16. The port number MUST be same for the sender and receiver to communicate.

17. Just as we use a byte array to send data, a byte array is again used to receive data as well.

18.       

19. 
    

20. Before we make the Socket.Receive method call, we must first bind the socket to a specific IP End Point on the local machine.

21. We’ll call the method Socket.Bind for this purpose and supply it the IPEndpoint which we created earlier.

22. But, let’s create a try/catch block here first.

23. 
    

24. Now the bind call

25.                sockBroadcaster.Bind(ipep);

26. This method call is going to associate the supplied IP End Point on the local machine to this socket.

27. Now we’re going to call the method to receive the data.

28. sockBroadcaster.Receive(

29. If you hover the mouse on this method call, you see that it returns an integer.

30. The description says that “Receives data from a bound socket into a receiver buffer.”

31. The int return tells us how many bytes of data have been received.

32. So, we’re going to pass in the receivedBuffer byte array as parameter.

33. And let’s store the return into an integer.

34. On the next line, we’re going to print the number of bytes received

35. I’m not printing the data received on purpose, it involves a few more details which I think are not important right now.

36. Let’s put the receive call in an infinite loop

37. And that’s it

38. Next video, we’re going to put both programs side by side and run them.

1. I’ve opened both projects side by side

2. First, I’m going to run the broadcast receiver.

3. When you’ll run the programs first time, the Windows Firewall is going to show a pop up asking if you want to allow this application to communicate through the network.

4. Click “Allow Access” on this dialog.

5. Next, I’ll going to run the broadcast sender

6. When the broadcast sender runs, we can see that two bytes get received at the receiver end.

7. We can run the broadcast sender as many times as we like.

8. Let’s inspect the local variables in the receiver application, right after the receive operation has finished.

9. I’ll stop the program, put a break point here and run again.

10. Now let’s run the sender one more time.

11. Inside the receiver code, let’s take a look at the locals.

12. I’ll go to “Debug” menu and open “Locals” window

13. You will see that the first two bytes of the receiveBuffer are set to the data sent by the sender.

14. These are actually the numeric form of the ASCII characters backslash r backslash n.

15. Let’s close the receiver and run the sender once again.

16. I’ll put a break in the Exception block to see if any exception is thrown when nobody receives the data broadcast by the sender.

17. 
    

18. 
    

19. There’s a lot more that we need to cover and that we are going to cover as you make progress in the course.

So far in the course, we’ve used socket method calls like Send, SendTo, Receive, and ReceiveFrom for UDP socket programming.

A key characteristic of these socket method calls is that they block our program flow.

Our program stops at the point where any of these methods get called.

For example’s sake, I’ve created the application of a new form using the BroadcastReceiver code.

You don’t need to write the code again; that’s why I’ll only show you the working application and not the code details.

The working source code is available in the downloads section of this video.

Let’s run the application.

Before clicking the “Start Receive” button, you’ll notice that I can resize the form, move it around, and even type text on it.

Now I’ll click the “Start Receive” button.

After this, you’ll notice that the application UI becomes unresponsive.

You can’t even close the application; how sick!

This is because the user interface thread is busy in a blocking or synchronous receive network input-output operation.

Let me run the BroadCastSender we created in the last section and send some data.

You’ll notice that the receiver will get all the text.

This is synchronous behavior.

The antonym of synchronous is Asynchronous or non-blocking application.

A long time ago, people used to write code to juggle multiple threads to perform I/O without blocking the UI thread.

Nowadays, it has become relatively simple.

In this course, I’ll show you how to perform UDP socket I/O asynchronously.

So that your application does not block network I/O.

I hope you understand the difference between synchronous and asynchronous applications and want to learn more about creating all glorious asynchronous applications.  Do ask all your questions in the Q&A section of the course. I’d love to answer your queries.

You’re going to create your own UDP chat application in this course.

It’s going to be a chatroom-like application(using the network to communicate)

Users will join the chatroom and leave it later, And A user might also send a message to all other users.

A block diagram is shown on the screen.

The application will be divided into multiple projects.

First, there’ll be a class library dll project to house the core logic of the application,

and then there’ll be two user interface projects.

One for the server to which all clients will connect.

And one for the clients.

The library project will be added in both the server and the client such that they may share some standard code.

More than one copy of the client application will run from various machines to communicate with each other.

I’ll head over to the Visual Studio

Let’s create a new solution for the chat server.

I’ll call it UDP Asynchronous Chat

It’s going to be a Windows Class Library.

The class library contains a default class in a file named Class1.cs, I’m going to rename it to UDPAsynchronousChatServer.

Visual Studio is going to rename the class inside of this file automatically.

Next, I’ll add a new project to this solution.

It’s going to be a WinForms project.

Let’s call it UDPChatServerForm

Lastly, I’ll open another copy of Visual Studio and add a new solution application UI here.

I’m going to save these solutions inside the same folder.

Let’s call it UDPChatClientForm

Afterward, let’s add a reference to our library project in both user interface projects.

Let’s build the solution. All looks good; we’ll add more logic to the solution in upcoming videos.

We use UDP socket programming and networking to ensure fast and efficient communication between users.

1. Before we venture further into asynchronous programming, you must understand what are callback methods.

2. The need arises from the way UDP related network operations work in .Net.

3. A special method call is used for asynchronous data transfer using UDP protocol.

4. 
   

5. Let me show you a block diagram<show block diagram>

6. So, For example... you might use the method call ReceiveFromAsync.

7. You offload the network I/O to this method call and move on.

8. Behind the scenes, this method call can be utilizing the .Net framework thread pool or any other technique, you don’t need to worry.

9. When the network I/O operation will be completed, the asynchronous I/O method will somehow inform your application code that the job you wanted it to do for your is done.

10. In case of ReceiveFromAsync method call, some data might have been received.

11. This is where callback methods come into play.

12. Callback methods are just “methods”... as the name implies.

13. These are certain methods inside your custom code, designated to be called back by the API or framework you are using for some purpose.

14. In our case, A callback method will get called by the sockets library to inform your code that some data has been received.

15. The sockets API will also provide some other useful data through the parameters of the callback methods.

16. You as an application developer will have the power to do whatever you want with that information.

17. <OPEN MSDN PAGE>

18. Let us open the MSDN page of the Socket.ReceiveFromAsync method and take a look.

19. This method call, takes a parameter which is an object of a special class, called SocketAsyncEventArgs

20. The remarks section shows us some properties of the object that must be populated in order to use the method call.

21. The callback method in this case is supplied by using the property SocketAsyncEventArgs.Completed.

22. The plus equals to(+=) operator is used to add a callback method to an event.

23. The callback method name comes at the right hand side.

24. Let me click this member and open it to see more details.

25. It says that the value of Completed will be .Net generic EventHandler type

26. Let’s open EventHandler MSDN page

27. <Open EventHandler MSDN Page>

28. All of these things mean that you will need to define a method in your code, which will have the return type void.

29. And which must take first parameter of type object, and second parameter of a class derived from EventArgs framework.

30. The EventHandler of SocketAsyncEventArgs mentioned here is going to be a method with the method signature shown on screen in the MSDN page.

31. Now Let’s go back to the completed event handler MSDN page.

32. The first parameter will contain the socket on which the event was raised.

33. The second parameter will contain the status and other information related to the operation completed.

34. Enough talk talk, now that you know what is an asynchronous method call and what are callback methods, let’s go ahead and add some code to the library project which we created earlier.

UDP sockets in C# are super efficient blazing fast. The UDP protocol allows for fast, low-latency data transfer, making it ideal for applications that require real-time communication. In C#, receiving data on UDP sockets is relatively straightforward. By creating a UdpClient object and binding it to a specific port, we can listen for incoming data from any source. Once data is received, it can be processed and acted upon as needed. Overall, I found working with UDP sockets in C# to be a seamless and effective experience.

1. Sending images, videos, and audio clips is a common practice in modern chat applications.

2. The foundational concepts related to transferring these types of media are pretty much the same.

3. Handling the content is then up to the receIving application, the communication layer is not commonly involved with the consumption of the media.

4. In this section, we are going to send an image file from one of the connected clients.

5. The server is going to pass it on to the other clients.

6. The clients are then going to paint the picture in a picture box.

7. We are going to modify the ChatPacket class for this purpose.

8. We are also going to modify the logic in UDP Asynchronous Chat Client class.

9. Once the class object has received the image, we will need to pass it to the forms application.

10. For this purpose we’re going to implement a new event ImageReceived

11. We’ll also define an event handler as well.

12. So let’s get going!

1. I’ve opened the Client Form and I am going to add a few controls here.

2. Those would be a text box for image path, a button to send the image, and a picture box to paint the received picture.

3. We can add a browse for image dialog here, but that would be a little too fancy I believe.

4. <Add the controls>

5. The ids of the controls will be shown on the screen.

6. <Show control ids>

7. I will double click the Send Image button.

8. First, I will add a sanity check to make sure that the file specified exists or not.

9. if(!File.Exists(tbFileSelectedPath.Text))

10. {

11. return;

12. }

13. Next, I’ll create an instance of Image class by calling the static method Image.FromFile.

14. It takes the file path as parameter.

15. We are going to deal in image files less than 64 KB for learning purposes.

16. Image imgFile = Image.FromFile(tbFileSelectedPath.Text);

17. Next, we’re going to write the contents of the file to a memory stream.

18. Let’s do it in a using block.

19. using (MemoryStream imageByteStream = new MemoryStream())

20. {

21. imgFile.Save(imageByteStream, System.Drawing.Imaging.ImageFormat.Jpeg);

22. Once the image is saved to an in memory byte stream.

23. We’re going to call a method on mChatClient for sending the image.

24. This method does not exist yet and We’re going to define later.

25. mChatClient.SendImage(

fileName: Path.GetFileName(tbFileSelectedPath.Text),

fileBytes: imageByteStream.ToArray(),

message: tbMessage.Text

);

1. The first parameter of this imaginary method will be the name of the file.

2. The second parameter will be an array of bytes, extractracted from imageByteStream which contains the image data we read from the file earlier.

3. And the final parameter will be any text which the user might want to send alongside the image.

4. Now I’m going to press Ctrl+. And select generate method.

5. The method is generated, but it is not implemented yet.

6. We are going to do that in the next video.

7. But before that, since we’ll be dealing in large amounts of data. We need to have larger byte array buffers.

8. Let us search for new byte[] and update the currently present number to 65000.

9. The statement is present once is server and once in the client.

1. I’ve opened the UDP Chat Client Form project and the Form1.cs file.

2. I’ll double click the button titled SendImage

3. I’m inside the button click event handler for SendImage.

4. Let’s press F12 and head over to the method we generated in the last video so that we could fill in the details.

5. First, I’m going to define an object of ChatPacket class.

6. ChatPacket packImage = new ChatPacket();

7. We’ll set the packet type to image.

8. packImage.PacketType = ChatPacket.PACKET_TYPE.IMAGE;

9. Message will go in message property and file name will go in fileInfo.

10. packImage.Message = message;

11. packImage.fileInfo = fileName;

12. The data bytes read from the file are going to go in RawData.

13. packImage.RawData = fileBytes;

14. Let’s get the bytes from the serialized version of the object.

15. var bytesToSend = Encoding.ASCII.GetBytes(

16. JsonConvert.SerializeObject(packImage));

17. SO now we have just a bunch of bytes which we want to send over to the server.

18. That means we’re going to just construct an object of SocketAsyncEventArgs like we usually do.

19. SocketAsyncEventArgs saea = new SocketAsyncEventArgs();

20. 
    

21. saea.SetBuffer(bytesToSend, 0, bytesToSend.Length);

22. 
    

23. saea.RemoteEndPoint = mChatServerEP;

24. 
    

25. Let’s save the file name in UserToken for future use.

26. saea.UserToken = fileName;

27. The call back will remain the same.

28. saea.Completed += SendMessageToKnownServerCompletedCallback;

29. 
    

30. And finally the SendToAsync method call.

31. mSockBroadCastSender.SendToAsync(saea);

32. Let’s store the return value and print it along with the SocketError proerty of the SocketAsyncEventArgs object.

33. Var ret = OnRaisePrintStringEvent(new PrintStringEventArgs( $"Image transfer status, returned: {ret} - Socket Error: {saea.SocketError}"));

34. 
    

35. This is it for this for the current video, in the next one we’re going to implement the logic for how to paint the picture received over the socket.

1. Now that our client is capable of sending an image, it is time to pass the raw data recevied , over to the user interface such that it can paint it.

2. We’re going to go to the UDP Asynchronous Chat Client class.

3. And to the callback method ReceiveConfirmationCompleted.

4. This method deserves a better name I believe, let’s rename it.

5. I will rename it to ReceivedContent and update all references.

6. Next, I’m going to go towards the bottom of the method and add an else condition.

7. else if (objPacketConfirmation.PacketType == ChatPacket.PACKET_TYPE.IMAGE){

8. OnRaiseImageReceived(new ImageReceivedEventArgs(

9. fileName: objPacketConfirmation.fileInfo,

10. fileData: objPacketConfirmation.RawData,

11. message: objPacketConfirmation.Message

12. ));

// add missing here

}

1. Neither the ImageReceivedEventArgs class nor the OnRaiseImageReceived method exists.

2. Let’s go ahead and define these.

3. First of all, the I will click ImageReceivedEventArgs and press ctrl+.

4. I will select “Generate class in new file”.

5. Next I will press control + F12 and go inside the newly defined class.

6. Let’s derive it from EventArgs, I’ll type colon and EventArgs.

7. And I’ll Ctrl + . and bring in System

8. And make the class public as well and the member fields public readonly as well.

9. Now let’s build the solution, an error will be shown saying OnRaiseImageReceived does not exist

10. Before fixing this, let’s write the line of code which would let us receive more data afterwards.

11. 
    

12. ReceiveTextFromServer(string.Empty, mChatServerEP as IPEndPoint);

13. .

14. I’m going to double click it to go to the source of the error.

15. Now I’ll hover the mouse over OnRaiseImageReceived and select option “Generate Method”.

16. Press F12 to go to the newly generated method.

17. Remove the default throw statement.

18. In here, we’re going to raise the event just as we did for PrintString in the past.

19. But first we need to define a public class member EventHandler of ImageReceivedEventArgs.

20. Public EventHandler<ImageReceivedEventArgs> ImageReceived;

21. Then I’ll proceed to defining the body of the method OnRaiseImageReceived.

22. The inner body of the method will be pretty simple, we’ll first create a local variable from the member.

23. EventHandler<ImageReceivedEventArgs> handler = ImageReceived;

24. After this, we’ll check the local variable for null and then raise the event.

25. if (handler != null)

26. {

27. handler(this, raiseImageReceivedArgs);

28. }

29. Now let’s go to the Forms project and write the subscribe code.

30. I’m going to the point where we are initializing the mChatClient object and attach the handler.

31. mChatClient.ImageReceived += chatClient_ImageReceived;

32. We’re going to define the handler method.

33. Inside the body of this method, we’ll create an object of a Bitmap.

34. Since this operation could fail also, we should put a try catch in here.

35. In catch block, we’ll just show the exception message and move on.

36. MessageBox.Show(exc.Message);

37. We’ll be using an object of MemoryStream to reconstruct the bitmap from the bytes received.

38. using (MemoryStream imageStream = new MemoryStream())Inside the using block, let’s write the value of e.fileData to the imageStream.

39. imageStream.Write(e.fileData, 0, e.fileData.Length);

40. Now we can create an object of bitmap from the stream.

41. bm = new Bitmap(imageStream, false);

42. Since this operation could fail also, we should put a try catch in here.

43. SInce this is going to be a cross threaded operation, we’ll need to create a separate method to update the picture box and use it through Invoke method call.

44. Let’s create an instance of Action of Bitmap and assign it a new method.

45. Action<Bitmap> updateImage = UpdateImageBox;

46. Now I’ll generate the right hand side method and go to it’s body.

47. Inside the method, we’ll assign the picture box the image we want it to display.

48. 
    

49. pbImageReceived.Image = obj;

50. We’ll go back to the ImageReceived call back and invoke the method UpdateImageBox.

51. pbImageReceived.Invoke(updateImage, new Image[] { bm });

52. Since we know that the user might have sent a message along with the image, let’s print it out as well.

53. Action<string> print = PrintToTextBox;

54. tbConsole.Invoke(print, new string[] { e.message});

55. 
    

56. This is it for the current video, we’re going to have a demo in the next one.

1. Let’s launch the server.

2. Next, I’m going to launch multiple instances of the client.

3. On all clients I’ll change local port numbers and click Broadcast.

4. Just for the sake of this demo, I’ve created some tiny images which could fit well within our 63 KB limit. <Show Images>

5. The image Koala-Tiny.jpg is one of those.

6. You can see these images on screen.

7. These images will also be available with the source code for you to download.

8. You’ll need to change the image path according to your own need.

9. I’m trying to arrange things such that you can see simultaneously when an image is received.

10. So, I’m going to click “Send Image” button on one of the clients. I can change the message as well.

11. “Here comes the Koala”.

12. 
    

13. We can send more than one images this way.

14. There’s another image, Penguins-Tiny.jpg, I will send it as well.

15. If the image path is wrong, the form will show an error locally. Let me try that.

16. What happens if we send a very large image? Well the transfer won’t work.

17. Now that you have the foundational knowledge about the subject, I suppose you can further explore niche cases on your own.

1. In this section, we learned how we can transfer JSON encoded byte data over UDP sockets

2. We wrote the logic to read an image from the disk on the client side.

3. Convert it into bytes, then encode into JSON using JsonConverter.Serialize and send across the wire.

4. There were minor changes on the server side. Like buffer size increase to accommodate large amounts of data.

5. In the client class, we wrote the code to receive an image and pass it on to the consumer.

6. We added a new event for this purpose.

7. I hope you found this section to be useful.

8. In principle, this is the end of the this course.

9. I might add a few more bonus videos in days to come to cover some more topics as well.

10. I also teach a course about TCP/IP socket programing here on UDemy. You might find that useful too.

11. Thanks very much for watching, feel free to ask questions in the Q&A section of the course. Bye.