Web Sockets in C#: How to Build Real-Time Applications

Web sockets are a powerful tool for building real-time applications. They allow you to establish a connection between a client and a server and send and receive data in real-time. This makes them ideal for applications that require frequent updates, such as chat rooms, online games, and collaborative editing tools. In this article, we will explore how to use web sockets in C# to build real-time applications.

Table of Contents show

What are Web Sockets?

Web sockets are a protocol for establishing a two-way communication channel between a client and a server over a single TCP connection. Unlike HTTP, which is a request-response protocol, web sockets allow for real-time, bi-directional communication between the client and server. This means that data can be sent from the server to the client at any time, and vice versa.

Web sockets are supported by all modern browsers, as well as many server-side frameworks and languages, including C#. They are based on the WebSocket API, which is a standard API for web sockets that is supported by all major browsers.

Getting Started with Web Sockets in C#

Before we can start using web sockets in C#, we need to set up our environment. We will need to install the WebSocketSharp library, which is a C# implementation of the WebSocket API. We can do this using NuGet, which is a package manager for .NET.

Open Visual Studio and create a new C# console application.
Right-click on the project in the Solution Explorer and select “Manage NuGet Packages”.
In the “Browse” tab, search for “WebSocketSharp” and install the package.

Once we have installed the WebSocketSharp library, we can start using web sockets in our C# application. The first step is to create a WebSocket server that will listen for incoming connections from clients.

Creating a WebSocket Server in C#

To create a WebSocket server in C#, we will need to use the WebSocket class from the WebSocketSharp library. We will also need to define a port number on which the server will listen for incoming connections. Here’s an example:

using WebSocketSharp;class Program{static void Main(string[] args){var server = new WebSocketServer("ws://localhost:8080");server.Start();}}

This code creates a WebSocket server that listens on port 8080 for incoming connections. We can run this code and it will start the WebSocket server.

Handling Incoming Connections in C#

Now that we have created a WebSocket server, we need to handle incoming connections from clients. We can do this by subscribing to the “OnConnection” event of the WebSocket server. Here’s an example:

using WebSocketSharp;class Program{static void Main(string[] args){var server = new WebSocketServer("ws://localhost:8080");server.Start();server.OnConnection += (sender, e) =>{Console.WriteLine("Client connected");};}}

This code subscribes to the “OnConnection” event of the WebSocket server and prints a message to the console when a client connects.

Sending and Receiving Messages in C#

Now that we can handle incoming connections, we need to be able to send and receive messages over the web socket connection. We can do this by subscribing to the “OnMessage” event of the WebSocket object. Here’s an example:

using WebSocketSharp;class Program{static void Main(string[] args){var server = new WebSocketServer("ws://localhost:8080");server.Start();server.OnConnection += (sender, e) =>{Console.WriteLine("Client connected");e.WebSocket.OnMessage += (sender, e) =>{Console.WriteLine("Message received: " + e.Data);e.WebSocket.Send("Message received: " + e.Data);};};}}

This code subscribes to the “OnMessage” event of the WebSocket object and prints a message to the console when a message is received. It also sends a response back to the client with the message that was received.

Implementing Real-Time Applications in C#

Now that we have the basics of web sockets in C#, we can start building real-time applications. Let’s take a look at an example of a chat room application.

First, we need to create a WebSocket server that will listen for incoming connections. We will also need to keep track of all the connected clients. Here’s an example:

using System.Collections.Generic;using WebSocketSharp;class Program{static List<WebSocket> _clients = new List<WebSocket>();
static void Main(string[] args){var server = new WebSocketServer("ws://localhost:8080");server.Start();server.OnConnection += (sender, e) =>{Console.WriteLine("Client connected");_clients.Add(e.WebSocket);e.WebSocket.OnMessage += (sender, e) =>{Console.WriteLine("Message received: " + e.Data);foreach (var client in _clients){client.Send("Message received: " + e.Data);}};e.WebSocket.OnClose += (sender, e) =>{Console.WriteLine("Client disconnected");_clients.Remove(e.WebSocket);};};}}

This code keeps track of all the connected clients in a list and broadcasts messages to all connected clients when a message is received.

Next, we need to create a client-side application that can connect to our WebSocket server and send and receive messages. We can do this using the WebSocket class from the WebSocketSharp library. Here’s an example:

using WebSocketSharp;class Program{static void Main(string[] args){var client = new WebSocket("ws://localhost:8080");client.OnOpen += (sender, e) =>{Console.WriteLine("Connected to server");client.Send("Hello, server!");};client.OnMessage += (sender, e) =>{Console.WriteLine("Message received: " + e.Data);};client.Connect();Console.ReadLine();}}

This code connects to the WebSocket server and sends a “Hello, server!” message. It also subscribes to the “OnMessage” event of the WebSocket object and prints messages that are received from the server.

Conclusion

Web sockets are a powerful tool for building real-time applications. They allow for real-time, bi-directional communication between a client and a server, which makes them ideal for applications that require frequent updates. In this article, we explored how to use web sockets in C# to build real-time applications, including creating a WebSocket server, handling incoming connections, sending and receiving messages, and implementing a chat room application. With this knowledge, you should be able to start building your own real-time applications using web sockets in C#.