C# Socket Programming Basics: Detailed Communication

Hello everyone! Today we will learn the basics of Socket programming in C#. A Socket is the foundation for network communication between computers, allowing data transmission between clients and servers. Whether developing a network game or an instant messaging application, mastering Socket programming is an essential skill.

What is a Socket?

A Socket is like a “telephone line” between two computers, enabling them to send and receive data. In C#, we use classes under the <span>System.Net.Sockets</span> namespace to implement Socket communication.

using System;

using System.Net;

using System.Net.Sockets;

using System.Text;


namespace SocketDemo
{
    class Program
    {
        // Socket server example code
        static void StartServer()
        {
            // Create a Socket object using IPv4 and TCP protocol
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, 
                                          SocketType.Stream, 
                                          ProtocolType.Tcp);
            
            // Bind IP address and port
            IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888);
            serverSocket.Bind(ipEndPoint);
            
            // Start listening, connection queue length is 10
            serverSocket.Listen(10);
            Console.WriteLine("Server started successfully, waiting for client connection...");
        }
    }
}

Server-Side Programming

The server side acts like an operator, responsible for waiting and handling client connection requests. Let’s see how to receive data sent by the client:

static void HandleClient(Socket clientSocket)
{
    byte[] buffer = new byte[1024];
    try
    {
        // Receive client data
        int length = clientSocket.Receive(buffer);
        string message = Encoding.UTF8.GetString(buffer, 0, length);
        Console.WriteLine($"Received message from client: {message}");
        
        // Send response data
        string response = "Server has received the message!";
        byte[] responseData = Encoding.UTF8.GetBytes(response);
        clientSocket.Send(responseData);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error occurred while handling client data: {ex.Message}");
    }
}

Tip: Using <span>using</span> statements ensures that the Socket correctly releases resources, avoiding memory leaks.

Client-Side Programming

The client side is like the person making a phone call, needing to actively connect to the server:

static void ConnectToServer()
{
    Socket clientSocket = new Socket(AddressFamily.InterNetwork, 
                                   SocketType.Stream, 
                                   ProtocolType.Tcp);
    try
    {
        // Connect to the server
        clientSocket.Connect("127.0.0.1", 8888);
        
        // Send data
        string message = "Hello, Server!";
        byte[] data = Encoding.UTF8.GetBytes(message);
        clientSocket.Send(data);
        
        // Receive server response
        byte[] buffer = new byte[1024];
        int length = clientSocket.Receive(buffer);
        string response = Encoding.UTF8.GetString(buffer, 0, length);
        Console.WriteLine($"Server response: {response}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to connect to server: {ex.Message}");
    }
}

Asynchronous Socket Programming

To improve program performance, we can use asynchronous methods to handle Socket communication:

async Task HandleClientAsync(Socket clientSocket)
{
    byte[] buffer = new byte[1024];
    try
    {
        // Asynchronously receive data
        int length = await Task.Factory.FromAsync(
            clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, null, null),
            clientSocket.EndReceive);
            
        string message = Encoding.UTF8.GetString(buffer, 0, length);
        Console.WriteLine($"Asynchronously received message: {message}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error occurred while processing asynchronously: {ex.Message}");
    }
}

Notes:

• Remember to properly handle the closure of the Socket and resource release

• Consider using a larger buffer to receive data

• In actual projects, it is recommended to use higher-level network libraries, such as SignalR

Running environment:

• .NET 6.0 or higher

• Visual Studio 2022

• NuGet packages: No additional packages required

Friends, that’s all for today’s C# learning journey! Remember to code along, and feel free to ask questions in the comments. Wishing everyone a happy learning experience, and may your C# development journey be ever-expanding! Code changes the world, and see you next time!