Introduction

In this article, learn C# socket programming. First, we will see how to create a C# socket and set up 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 them 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 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.

Figure 1

Socket client and server communication.

In socket communication, one node acts as a listener, and the 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 set up 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 a 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.

using System;  
using System.Net;  
using System.Net.Sockets;  
using System.Text;  
  
// Socket Listener acts as a server and listens to the incoming   
// messages on the specified port and protocol.  
public class SocketListener  
{  
    public static int Main(String[] args)  
    {  
        StartServer();  
        return 0;  
    }  
  
    public static void StartServer()  
    {  
        // Get Host IP Address that is used to establish a connection  
        // In this case, we get one IP address of localhost that is IP : 127.0.0.1  
        // If a host has multiple addresses, you will get a list of addresses  
        IPHostEntry host = Dns.GetHostEntry("localhost");  
        IPAddress ipAddress = host.AddressList[0];  
        IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);    
      
        try {   
  
            // Create a Socket that will use Tcp protocol      
            Socket listener = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  
            // A Socket must be associated with an endpoint using the Bind method  
            listener.Bind(localEndPoint);  
            // Specify how many requests a Socket can listen before it gives Server busy response.  
            // We will listen 10 requests at a time  
            listener.Listen(10);  
  
            Console.WriteLine("Waiting for a connection...");  
            Socket handler = listener.Accept();  
  
             // Incoming data from the client.    
             string data = null;  
             byte[] bytes = null;  
  
            while (true)  
            {  
                bytes = new byte[1024];  
                int bytesRec = handler.Receive(bytes);  
                data += Encoding.ASCII.GetString(bytes, 0, bytesRec);  
                if (data.IndexOf("<EOF>") > -1)  
                {  
                    break;  
                }  
            }  
  
            Console.WriteLine("Text received : {0}", data);  
  
            byte[] msg = Encoding.ASCII.GetBytes(data);  
            handler.Send(msg);  
            handler.Shutdown(SocketShutdown.Both);  
            handler.Close();  
        }  
        catch (Exception e)  
        {  
            Console.WriteLine(e.ToString());  
        }  
  
        Console.WriteLine("\n Press any key to continue...");  
        Console.ReadKey();  
    }          
} 

The code above creates a Socket listener on the local host using TCP protocol, and any messages captured from the client, it displayed it on the console. The listener can request 10 clients at a time, and the 11th request will give a server busy message.

Output

Figure 2

Step 2. Create a Client

A client application is one that establishes a connection with a server/listener and sends a message. Create another .NET Core console application and write the following code

The sample code below creates a client application that creates a socket connection with the listener on the given IP and the port and sends a message. 

using System;  
using System.Net;  
using System.Net.Sockets;  
using System.Text;  
  
// Client app is the one sending messages to a Server/listener.   
// Both listener and client can send messages back and forth once a   
// communication is established.  
public class SocketClient  
{  
    public static int Main(String[] args)  
    {  
        StartClient();  
        return 0;  
    }  
  
    public static void StartClient()  
    {  
        byte[] bytes = new byte[1024];  
  
        try  
        {  
            // Connect to a Remote server  
            // Get Host IP Address that is used to establish a connection  
            // In this case, we get one IP address of localhost that is IP : 127.0.0.1  
            // If a host has multiple addresses, you will get a list of addresses  
            IPHostEntry host = Dns.GetHostEntry("localhost");  
            IPAddress ipAddress = host.AddressList[0];  
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);  
  
            // Create a TCP/IP  socket.    
            Socket sender = new Socket(ipAddress.AddressFamily,  
                SocketType.Stream, ProtocolType.Tcp);  
  
            // Connect the socket to the remote endpoint. Catch any errors.    
            try  
            {  
                // Connect to Remote EndPoint  
                sender.Connect(remoteEP);  
  
                Console.WriteLine("Socket connected to {0}",  
                    sender.RemoteEndPoint.ToString());  
  
                // Encode the data string into a byte array.    
                byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");  
  
                // Send the data through the socket.    
                int bytesSent = sender.Send(msg);  
  
                // Receive the response from the remote device.    
                int bytesRec = sender.Receive(bytes);  
                Console.WriteLine("Echoed test = {0}",  
                    Encoding.ASCII.GetString(bytes, 0, bytesRec));  
  
                // Release the socket.    
                sender.Shutdown(SocketShutdown.Both);  
                sender.Close();  
  
            }  
            catch (ArgumentNullException ane)  
            {  
                Console.WriteLine("ArgumentNullException : {0}", ane.ToString());  
            }  
            catch (SocketException se)  
            {  
                Console.WriteLine("SocketException : {0}", se.ToString());  
            }  
            catch (Exception e)  
            {  
                Console.WriteLine("Unexpected exception : {0}", e.ToString());  
            }  
  
        }  
        catch (Exception e)  
        {  
            Console.WriteLine(e.ToString());  
        }  
    }  
} 

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 the client runs, you will see the message is sent to the server. See Figure 2

Figure 3

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 a 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.