C# WebSockets: Implementing Real-Time Communication

Hello, C# developers! Today, we’re diving into WebSockets, a protocol for full-duplex communication channels over a single TCP connection. WebSockets are ideal for applications that require real-time engagement, such as chat apps, live notifications, or interactive gaming. This post will explain how to set up a WebSocket server and client in C# to enable real-time communication.

What are WebSockets?

WebSockets provide a bi-directional, full-duplex communication channel between a client and server, unlike traditional HTTP, which is unidirectional. This protocol allows both the server and client to send messages independently, reducing latency and improving performance for real-time applications.

Setting Up a WebSocket Server in C#

To create a WebSocket server in C#, you can use the System.Net.WebSockets namespace. Below is a simple WebSocket server implemented using an ASP.NET Core application.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add necessary services
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseWebSockets(); // Enable WebSocket support

        app.Map("/ws", appBuilder =>
        {
            appBuilder.Run(async context =>
            {
                if (context.WebSockets.IsWebSocketRequest)
                {
                    WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
                    await HandleWebSocketAsync(webSocket);
                }
                else
                {
                    context.Response.StatusCode = 400;
                }
            });
        });
    }

    private async Task HandleWebSocketAsync(WebSocket webSocket)
    {
        var buffer = new byte[1024 * 4];
        WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        while (!result.CloseStatus.HasValue)
        {
            // Echo the received message back
            await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);
            result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        }
        await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
    }
}

In this example, we set up an ASP.NET Core application that supports WebSockets. When a client connects to the /ws endpoint, the server accepts the WebSocket connection, and we handle receiving and sending messages in the HandleWebSocketAsync method.

Creating a WebSocket Client

Next, let’s create a simple WebSocket client that connects to our server:

using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class WebSocketClient
{
    private ClientWebSocket _client;

    public async Task ConnectAsync(string uri)
    {
        _client = new ClientWebSocket();
        await _client.ConnectAsync(new Uri(uri), CancellationToken.None);
        Console.WriteLine("Connected to the server.");
        await SendAsync("Hello Server!");
        await ReceiveAsync();
    }

    private async Task SendAsync(string message)
    {
        var buffer = Encoding.UTF8.GetBytes(message);
        await _client.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
    }

    private async Task ReceiveAsync()
    {
        var buffer = new byte[1024];
        WebSocketReceiveResult result = await _client.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
        Console.WriteLine($"Received: {message}");
    }
}

This client connects to the WebSocket server, sends a greeting message, and listens for any responses from the server. You can call the ConnectAsync method with the server’s URL to initiate the connection.

Best Practices for WebSocket Development

• Handle Connection State: Implement methods to manage the connection state (open, closed, error) effectively.
• Implement Heartbeat: Use heartbeat or ping messages to monitor and maintain the connection status.
• Manage Sessions: Keep track of active WebSocket sessions to handle message routing and broadcasting efficiently.

Conclusion

WebSockets provide an efficient way to build real-time applications, allowing for interactive communication between the client and server. By implementing WebSocket functionality using C#, you can create responsive and engaging user experiences. Start exploring WebSockets in your applications to take advantage of real-time features!

To learn more about ITER Academy, visit our website. Visit Here