Introduction
Web applications have evolved and they now require real-time communication between clients and servers. However, traditional HTTP requests have limitations when it comes to establishing persistent connections for ongoing data exchange. This is where WebSocket, a powerful communication protocol, comes into play. It enables full-duplex communication between a client and a server.
What is WebSocket?
WebSocket is a protocol that provides a full-duplex communication channel over a single, long-lived TCP connection. It facilitates real-time, bi-directional communication between a client and a server. Unlike HTTP, which follows a request-response model, WebSocket allows both the client and server to send messages to each other independently.
WebSocket in .NET
In the .NET ecosystem, developers can leverage the System.Net.WebSockets namespace to implement WebSocket functionality in their applications. .NET provides robust support for working with WebSockets, making it relatively straightforward to create WebSocket-based services.
Implementing a WebSocket Server in .NET
To create a WebSocket server in .NET, you can start by setting up WebSocketListener and handling incoming connections. Here's an example.
using System;
using System.Net;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;
class WebSocketServer
{
public async Task StartServer(string ipAddress, int port)
{
HttpListener listener = new HttpListener();
listener.Prefixes.Add($"http://{ipAddress}:{port}/");
listener.Start();
Console.WriteLine("Server started. Waiting for connections...");
while (true)
{
HttpListenerContext context = await listener.GetContextAsync();
if (context.Request.IsWebSocketRequest)
{
ProcessWebSocketRequest(context);
}
else
{
context.Response.StatusCode = 400;
context.Response.Close();
}
}
}
private async Task ProcessWebSocketRequest(HttpListenerContext context)
{
HttpListenerWebSocketContext webSocketContext = await context.AcceptWebSocketAsync(null);
WebSocket socket = webSocketContext.WebSocket;
// Handle incoming messages
byte[] buffer = new byte[1024];
while (socket.State == WebSocketState.Open)
{
WebSocketReceiveResult result = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Text)
{
string receivedMessage = System.Text.Encoding.UTF8.GetString(buffer, 0, result.Count);
Console.WriteLine($"Received message: {receivedMessage}");
// Echo back the received message
await socket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), WebSocketMessageType.Text, true, CancellationToken.None);
}
else if (result.MessageType == WebSocketMessageType.Close)
{
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
}
}
}
}
Implementing a WebSocket Client in .NET
Creating a WebSocket client in .NET involves establishing a connection to a WebSocket server and handling messages. Here's an example.
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
class WebSocketClient
{
public async Task ConnectToServer(string serverUri)
{
ClientWebSocket clientWebSocket = new ClientWebSocket();
await clientWebSocket.ConnectAsync(new Uri(serverUri), CancellationToken.None);
Console.WriteLine("Connected to the server. Start sending messages...");
// Send messages to the server
string message = "Hello, WebSocket!";
byte[] buffer = Encoding.UTF8.GetBytes(message);
await clientWebSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
// Receive messages from the server
byte[] receiveBuffer = new byte[1024];
while (clientWebSocket.State == WebSocketState.Open)
{
WebSocketReceiveResult result = await clientWebSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Text)
{
string receivedMessage = Encoding.UTF8.GetString(receiveBuffer, 0, result.Count);
Console.WriteLine($"Received message from server: {receivedMessage}");
}
}
}
}
Conclusion
WebSocket in .NET provides a powerful means to establish real-time communication between clients and servers, enabling efficient data exchange in modern web applications. Whether you're building chat applications, real-time dashboards, or collaborative tools, WebSocket's bidirectional communication capabilities offer a robust solution for delivering responsive and interactive experiences to users. With .NET's support for WebSocket functionality, developers have the tools necessary to implement this technology effectively within their applications.