Socket Programming In C#

In this article, we will see how to create a C# socket and setup a listener server node that starts listening to any messages coming its way via the predefined IP and protocol. We will also see how to create a client application that will send messages to a listener server and read it using Sockets. The sample code is written in C# and .NET Core.

Sockets in computer networks are used to establish a connection between two or more computers and used to send data from one computer to another. Each computer in the network is called a node. Sockets use nodes’ IP addresses and a network protocol to create a secure channel of communication and use this channel to transfer data.
 
 
Socket client and server communication.
 
In socket communication, one node acts as a listener and other node acts as a client. The listener node opens itself upon a pre-established IP address and on a predefined protocol and starts listening. Clients who want to send messages to the server start broadcasting messages on the same IP address and same protocol. A typical socket connection uses the Transmission Control Protocol (TCP) to communicate.
 
In this article, we will see how to create a socket and setup a listener server node that starts listening to any messages coming to it via the predefined IP and protocol. We will also see how to create a client application that will send message to the listener server and read it. The sample code is written in C# and .NET Core.
 

Step 1 - Create a Listener

 
Create a .NET Core Console app and write the following code listed in Listing 1.  
  1. using System;  
  2. using System.Net;  
  3. using System.Net.Sockets;  
  4. using System.Text;  
  5.   
  6. // Socket Listener acts as a server and listens to the incoming   
  7. // messages on the specified port and protocol.  
  8. public class SocketListener  
  9. {  
  10.     public static int Main(String[] args)  
  11.     {  
  12.         StartServer();  
  13.         return 0;  
  14.     }  
  15.   
  16.      
  17.     public static void StartServer()  
  18.     {  
  19.         // Get Host IP Address that is used to establish a connection  
  20.         // In this case, we get one IP address of localhost that is IP : 127.0.0.1  
  21.         // If a host has multiple addresses, you will get a list of addresses  
  22.         IPHostEntry host = Dns.GetHostEntry("localhost");  
  23.         IPAddress ipAddress = host.AddressList[0];  
  24.         IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);    
  25.         
  26.   
  27.         try {   
  28.   
  29.             // Create a Socket that will use Tcp protocol      
  30.             Socket listener = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  
  31.             // A Socket must be associated with an endpoint using the Bind method  
  32.             listener.Bind(localEndPoint);  
  33.             // Specify how many requests a Socket can listen before it gives Server busy response.  
  34.             // We will listen 10 requests at a time  
  35.             listener.Listen(10);  
  36.   
  37.             Console.WriteLine("Waiting for a connection...");  
  38.             Socket handler = listener.Accept();  
  39.   
  40.              // Incoming data from the client.    
  41.              string data = null;  
  42.              byte[] bytes = null;  
  43.   
  44.             while (true)  
  45.             {  
  46.                 bytes = new byte[1024];  
  47.                 int bytesRec = handler.Receive(bytes);  
  48.                 data += Encoding.ASCII.GetString(bytes, 0, bytesRec);  
  49.                 if (data.IndexOf("<EOF>") > -1)  
  50.                 {  
  51.                     break;  
  52.                 }  
  53.             }  
  54.   
  55.             Console.WriteLine("Text received : {0}", data);  
  56.   
  57.             byte[] msg = Encoding.ASCII.GetBytes(data);  
  58.             handler.Send(msg);  
  59.             handler.Shutdown(SocketShutdown.Both);  
  60.             handler.Close();  
  61.         }  
  62.         catch (Exception e)  
  63.         {  
  64.             Console.WriteLine(e.ToString());  
  65.         }  
  66.   
  67.         Console.WriteLine("\n Press any key to continue...");  
  68.         Console.ReadKey();  
  69.     }          
  70. }  
Listing 1.
 
The code listed in Listing 1 creates a Socket listener on the local host using TCP protocol and any messages captured from the client, it displays it on the console. The listener can request 10 clients at a time and the 11th request will give a server busy message.
 
The output will look like Figure 1.
 
 
Figure 1.
 

Step 2 - Create a Client 

 
A client application is the one that establishes a connection with a server/listener and send a message. Create another .NET Core console application and write the following code in Listing 2.
 
The sample code in Listing 2 creates a client application that creates a socket connection with the listener on the given IP and the port, and sends a message. 
  1. using System;  
  2. using System.Net;  
  3. using System.Net.Sockets;  
  4. using System.Text;  
  5.   
  6. // Client app is the one sending messages to a Server/listener.   
  7. // Both listener and client can send messages back and forth once a   
  8. // communication is established.  
  9. public class SocketClient  
  10. {  
  11.     public static int Main(String[] args)  
  12.     {  
  13.         StartClient();  
  14.         return 0;  
  15.     }  
  16.   
  17.   
  18.     public static void StartClient()  
  19.     {  
  20.         byte[] bytes = new byte[1024];  
  21.   
  22.         try  
  23.         {  
  24.             // Connect to a Remote server  
  25.             // Get Host IP Address that is used to establish a connection  
  26.             // In this case, we get one IP address of localhost that is IP : 127.0.0.1  
  27.             // If a host has multiple addresses, you will get a list of addresses  
  28.             IPHostEntry host = Dns.GetHostEntry("localhost");  
  29.             IPAddress ipAddress = host.AddressList[0];  
  30.             IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);  
  31.   
  32.             // Create a TCP/IP  socket.    
  33.             Socket sender = new Socket(ipAddress.AddressFamily,  
  34.                 SocketType.Stream, ProtocolType.Tcp);  
  35.   
  36.             // Connect the socket to the remote endpoint. Catch any errors.    
  37.             try  
  38.             {  
  39.                 // Connect to Remote EndPoint  
  40.                 sender.Connect(remoteEP);  
  41.   
  42.                 Console.WriteLine("Socket connected to {0}",  
  43.                     sender.RemoteEndPoint.ToString());  
  44.   
  45.                 // Encode the data string into a byte array.    
  46.                 byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");  
  47.   
  48.                 // Send the data through the socket.    
  49.                 int bytesSent = sender.Send(msg);  
  50.   
  51.                 // Receive the response from the remote device.    
  52.                 int bytesRec = sender.Receive(bytes);  
  53.                 Console.WriteLine("Echoed test = {0}",  
  54.                     Encoding.ASCII.GetString(bytes, 0, bytesRec));  
  55.   
  56.                 // Release the socket.    
  57.                 sender.Shutdown(SocketShutdown.Both);  
  58.                 sender.Close();  
  59.   
  60.             }  
  61.             catch (ArgumentNullException ane)  
  62.             {  
  63.                 Console.WriteLine("ArgumentNullException : {0}", ane.ToString());  
  64.             }  
  65.             catch (SocketException se)  
  66.             {  
  67.                 Console.WriteLine("SocketException : {0}", se.ToString());  
  68.             }  
  69.             catch (Exception e)  
  70.             {  
  71.                 Console.WriteLine("Unexpected exception : {0}", e.ToString());  
  72.             }  
  73.   
  74.         }  
  75.         catch (Exception e)  
  76.         {  
  77.             Console.WriteLine(e.ToString());  
  78.         }  
  79.     }  
  80. }  
Listing 2.
 

Step 3 - Test and Run

 
Now build both projects and run both applications from the command line. You will see the message sent by the client is read and displayed by the listener. 
 
Once client runs, you will see the message is sent to the server. See Figure 2 
 
 
Figure 2.
 

Summary

 
In this article, you learned how to use Sockets in C# and .NET Core to create a client and a server to communicate via the TCP/IP protocol. This sample works on local machine but you can use the same code on a network. All you need to do is change the IP address of the host.