Le serveur Socket.IO se présente comme une bibliothèque robuste, facilitant la communication en temps réel, bidirectionnelle et pilotée par événements. Il est largement utilisé dans les applications Web pour des tâches telles que les applications de chat, les mises à jour en direct et les plateformes collaboratives. Bien que Socket.IO soit généralement associé à JavaScript, il peut également être utilisé efficacement côté client avec C#. Parfois, le client peut être un navigateur web. Dans cet article, nous allons explorer comment configurer et utiliser un client Socket.IO dans un environnement C#. Nous passerons en revue quelques exemples de base et conclurons avec les avantages et les cas d'utilisation potentiels.
Socket.IOLa connexion Socket.IO peut être établie avec différents transports de bas niveau :
HTTP long-polling
Web Sockets
Transport Web
Ouvrez Visual Studio et sélectionnez Créer un nouveau projet dans la fenêtre de démarrage.
Pour créer une application console dans Visual Studio 2022, lancez Visual Studio et sélectionnez "Créer un nouveau projet" depuis la fenêtre de démarrage. Choisissez le modèle "Application Console", configurez le projet avec un nom et un emplacement, et assurez-vous que .NET 6.0 est sélectionné.
Socket.IO, une bibliothèque JavaScript, permet aux clients et serveurs web de s'engager dans une communication en temps réel. Il se compose de deux parties :
Pour utiliser Socket.IO pour les applications .NET dans Visual Studio, vous aurez besoin d'une implémentation serveur compatible. Une telle implémentation est le SocketIoClientDotNet for .NET, qui permet à un client Socket.IO de se connecter à un Socket.IO depuis une application C#.
Tout d'abord, installez les paquets NuGet requis. Vous pouvez le faire via la Console du Package Manager ou en ajoutant les références à votre fichier de projet :
Exécuter cette commande incorporera la bibliothèque cliente Socket.IO dans votre projet .NET, permettant à votre application C# de se connecter avec un serveur Socket.IO, facilitant la communication entre les utilisateurs et le système.
Avant de plonger dans le client C#, créons un exemple de base de Socket IO en utilisant un .NET Core Console App dans Visual Studio. Cela nous aidera à tester l'implémentation du client.
Le code suivant met en place un serveur Socket.IO de base en C# qui écoute les connexions clientes sur le port 3000. Lorsqu'un client envoie un message, le serveur journalise le message et répond au client en confirmant la réception.
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Quobject.SocketIoClientDotNet.Client;
namespace DemoApp
{
internal class Program
{
static void Main(string[] args)
{
// Connect to the Socket.IO server
var socket = IO.Socket("http://localhost:3000");
// Listen for the "connect" event
socket.On(Socket.EVENT_CONNECT, () =>
{
Console.WriteLine("Connected to the server!");
// Emit a message to the server
socket.Emit("message", "Hello from C# client!");
// Listen for messages from the server
socket.On("message", (data) =>
{
Console.WriteLine("Message from server: " + data);
});
});
// Listen for the "disconnect" event
socket.On(Socket.EVENT_DISCONNECT, () =>
{
Console.WriteLine("Disconnected from the server!");
});
// Keep the console window open
Console.ReadLine();
}
}
}Imports System
Imports System.Net.WebSockets
Imports System.Text
Imports System.Threading
Imports System.Threading.Tasks
Imports Quobject.SocketIoClientDotNet.Client
Namespace DemoApp
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Connect to the Socket.IO server
Dim socket = IO.Socket("http://localhost:3000")
' Listen for the "connect" event
socket.On(Socket.EVENT_CONNECT, Sub()
Console.WriteLine("Connected to the server!")
' Emit a message to the server
socket.Emit("message", "Hello from C# client!")
' Listen for messages from the server
socket.On("message", Sub(data)
Console.WriteLine("Message from server: " & data)
End Sub)
End Sub)
' Listen for the "disconnect" event
socket.On(Socket.EVENT_DISCONNECT, Sub()
Console.WriteLine("Disconnected from the server!")
End Sub)
' Keep the console window open
Console.ReadLine()
End Sub
End Class
End NamespaceDans l'extrait de code, nous créons d'abord une instance de client Socket.IO en appelant IO.Socket("http://localhost:3000"), qui se connecte au serveur local fonctionnant sur le port 3000 sur la machine client.
Lors de la connexion réussie (Socket.EVENT_CONNECT), nous imprimons un message indiquant que nous sommes connectés au serveur.
Ensuite, nous émettons un message du client au serveur en utilisant socket.Emit("message", "Hello from C# client!"). Cela envoie un message avec le contenu "Hello from C# client!" au serveur.
Ensuite, nous écoutons les messages du serveur en enregistrant un rappel pour l'événement "message" à l'aide de `socket.On("message", (data) => { ... }). Lorsque le serveur envoie un événement "message", la fonction de rappel est invoquée, et nous imprimons le message reçu sur la console.
Si la connexion au serveur est déconnectée du client (Socket.EVENT_DISCONNECT), nous imprimons un message indiquant la déconnexion.
Enfin, la méthode Console.ReadLine() garde la fenêtre de console ouverte pour que le programme ne se termine pas immédiatement après l'exécution. Cela nous permet de voir la sortie et assure que le programme ne se termine pas prématurément.
Le long-polling est une technique utilisée dans le développement web qui utilise une bibliothèque pour envoyer des messages entre un client (généralement un navigateur web) et un serveur. Il permet une communication en temps réel en déclenchant des événements sur le serveur, qui peuvent alors être reçus par le client sans besoin de sondage continu. Cette méthode est particulièrement utile pour les applications nécessitant des mises à jour immédiates, telles que les applications de chat ou les tickers boursiers.
WebSocket facilite la communication bidirectionnelle en établissant des canaux de communication full-duplex sur une seule connexion TCP. Ce protocole permet une interaction en temps réel entre un client, généralement un navigateur web, et un serveur, permettant aux deux parties d'échanger des messages de manière asynchrone.
Le client envoie une demande de poignée de main WebSocket au serveur, indiquant son désir d'établir une connexion WebSocket. Après avoir reçu la demande de poignée de main, le serveur répond par une réponse de poignée de main WebSocket, indiquant que la connexion a été établie avec succès. Les messages envoyés via la connexion WebSocket peuvent être dans n'importe quel format (par exemple, texte ou binaire) et peuvent être envoyés et reçus de manière asynchrone.
Web Transport, en tant que protocole de pointe, introduit des fonctionnalités supplémentaires pour améliorer la communication web au-delà des limitations des protocoles traditionnels comme TCP et UDP. En exploitant UDP et QUIC, il répond aux lacunes de ses prédécesseurs, le rendant plus convivial et efficace. Pour les utilisateurs, cela se traduit par une latence réduite et un meilleur contrôle de la congestion, offrant finalement une expérience web plus fluide et plus réactive. De plus, Web Transport offre de meilleures mesures de sécurité, assurant une transmission de données plus sûre par rapport à TCP. Avec ces avancées, Web Transport atténue les aspects chronophages du transfert de données, optimisant la performance globale pour les clients et les serveurs.
Voici un exemple de base de la façon dont Web Transport peut être utilisé dans une application web :
using System;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;
namespace SocketIO.Demo
{
class Program
{
static async Task Main(string[] args)
{
// The WebSocket URI
string uri = "wss://echo.websocket.org";
// Creating a new WebSocket connection
using (ClientWebSocket webSocket = new ClientWebSocket())
{
await webSocket.ConnectAsync(new Uri(uri), CancellationToken.None);
Console.WriteLine("Connected to the server");
// Sending data over the WebSocket
byte[] sendBuffer = new byte[] { 1, 2, 3, 4 };
await webSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, true, CancellationToken.None);
Console.WriteLine("Data sent to the server");
// Receiving data from the WebSocket
byte[] receiveBuffer = new byte[1024];
WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
byte[] data = new byte[result.Count];
Array.Copy(receiveBuffer, data, result.Count);
Console.WriteLine("Received data: " + BitConverter.ToString(data));
}
}
}
}Imports System
Imports System.Net.WebSockets
Imports System.Threading
Imports System.Threading.Tasks
Namespace SocketIO.Demo
Friend Class Program
Shared Async Function Main(ByVal args() As String) As Task
' The WebSocket URI
Dim uri As String = "wss://echo.websocket.org"
' Creating a new WebSocket connection
Using webSocket As New ClientWebSocket()
Await webSocket.ConnectAsync(New Uri(uri), CancellationToken.None)
Console.WriteLine("Connected to the server")
' Sending data over the WebSocket
Dim sendBuffer() As Byte = { 1, 2, 3, 4 }
Await webSocket.SendAsync(New ArraySegment(Of Byte)(sendBuffer), WebSocketMessageType.Binary, True, CancellationToken.None)
Console.WriteLine("Data sent to the server")
' Receiving data from the WebSocket
Dim receiveBuffer(1023) As Byte
Dim result As WebSocketReceiveResult = Await webSocket.ReceiveAsync(New ArraySegment(Of Byte)(receiveBuffer), CancellationToken.None)
Dim data(result.Count - 1) As Byte
Array.Copy(receiveBuffer, data, result.Count)
Console.WriteLine("Received data: " & BitConverter.ToString(data))
End Using
End Function
End Class
End NamespaceDans cet exemple, nous créons d'abord une nouvelle connexion WebSocket à un serveur en utilisant une URL WebSocket (wss://echo.websocket.org). Ensuite, nous créons un flux bidirectionnel sur la connexion et envoyons quelques données ([1, 2, 3, 4]) sur le flux. Enfin, nous lisons des données du flux et les enregistrons dans la console.
Lorsque vous exécutez l'application avec le serveur d'écho WebSocket, la sortie devrait ressembler à ceci :
IronPDF est une bibliothèque PDF .NET complète spécialement conçue pour les développeurs travaillant avec C#. Cet outil puissant permet aux développeurs de créer, manipuler et lire facilement des fichiers PDF dans leurs applications. Avec IronPDF, les développeurs peuvent générer des documents PDF à partir de chaînes HTML, fichiers HTML et URL, le rendant très polyvalent pour divers cas d'utilisation. De plus, IronPDF offre des fonctionnalités avancées d'édition PDF comme l'ajout d'en-têtes, de pieds de page, de filigranes, et bien plus encore. Son intégration transparente dans les projets C# via le Package Manager NuGet simplifie le processus de travail avec des fichiers PDF, rationalise le développement et améliore la productivité.
Installez IronPDF dans Visual Studio ou depuis la ligne de commande en utilisant le Package Manager NuGet. Dans Visual Studio, allez à la console :
Voici un exemple simple utilisant IronPDF pour convertir des données binaires en fichier PDF. Appelez la méthode GeneratePDF dans la méthode Main et passez les données comme paramètre que nous avions dans l'exemple ci-dessus :
using System;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;
namespace SocketIO.Demo
{
class Program
{
static async Task Main(string[] args)
{
// The WebSocket URI
string uri = "wss://echo.websocket.org";
// Creating a new WebSocket connection
using (ClientWebSocket webSocket = new ClientWebSocket())
{
await webSocket.ConnectAsync(new Uri(uri), CancellationToken.None);
Console.WriteLine("Connected to the server");
// Sending data over the WebSocket
byte[] sendBuffer = new byte[] { 1, 2, 3, 4 };
await webSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, true, CancellationToken.None);
Console.WriteLine("Data sent to the server");
// Receiving data from the WebSocket
byte[] receiveBuffer = new byte[1024];
WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
byte[] data = new byte[result.Count];
Array.Copy(receiveBuffer, data, result.Count);
Console.WriteLine("Received data: " + BitConverter.ToString(data));
// Data to generate in PDF file
string pdfData = BitConverter.ToString(data);
PDFGenerator.GeneratePDF(pdfData);
}
}
}
}Imports System
Imports System.Net.WebSockets
Imports System.Threading
Imports System.Threading.Tasks
Namespace SocketIO.Demo
Friend Class Program
Shared Async Function Main(ByVal args() As String) As Task
' The WebSocket URI
Dim uri As String = "wss://echo.websocket.org"
' Creating a new WebSocket connection
Using webSocket As New ClientWebSocket()
Await webSocket.ConnectAsync(New Uri(uri), CancellationToken.None)
Console.WriteLine("Connected to the server")
' Sending data over the WebSocket
Dim sendBuffer() As Byte = { 1, 2, 3, 4 }
Await webSocket.SendAsync(New ArraySegment(Of Byte)(sendBuffer), WebSocketMessageType.Binary, True, CancellationToken.None)
Console.WriteLine("Data sent to the server")
' Receiving data from the WebSocket
Dim receiveBuffer(1023) As Byte
Dim result As WebSocketReceiveResult = Await webSocket.ReceiveAsync(New ArraySegment(Of Byte)(receiveBuffer), CancellationToken.None)
Dim data(result.Count - 1) As Byte
Array.Copy(receiveBuffer, data, result.Count)
Console.WriteLine("Received data: " & BitConverter.ToString(data))
' Data to generate in PDF file
Dim pdfData As String = BitConverter.ToString(data)
PDFGenerator.GeneratePDF(pdfData)
End Using
End Function
End Class
End Namespaceusing IronPdf;
namespace SocketIO.Demo
{
public class PDFGenerator
{
public static void GeneratePDF(string data)
{
IronPdf.License.LicenseKey = "Your-Licence-Key-Here";
Console.WriteLine("PDF Generating Started...");
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
Console.WriteLine("PDF Processing ....");
var pdf = renderer.RenderHtmlAsPdf($"<h1>Received Data</h1><p>{data}</p>");
string filePath = "Data.pdf";
pdf.SaveAs(filePath);
Console.WriteLine($"PDF Generation Completed. File Saved as {filePath}");
}
}
}Imports IronPdf
Namespace SocketIO.Demo
Public Class PDFGenerator
Public Shared Sub GeneratePDF(ByVal data As String)
IronPdf.License.LicenseKey = "Your-Licence-Key-Here"
Console.WriteLine("PDF Generating Started...")
' Instantiate Renderer
Dim renderer = New ChromePdfRenderer()
Console.WriteLine("PDF Processing ....")
Dim pdf = renderer.RenderHtmlAsPdf($"<h1>Received Data</h1><p>{data}</p>")
Dim filePath As String = "Data.pdf"
pdf.SaveAs(filePath)
Console.WriteLine($"PDF Generation Completed. File Saved as {filePath}")
End Sub
End Class
End Namespace
Dans le code fourni, IronPDF est utilisé pour générer un document PDF à partir d'une chaîne hexadécimale reçue via une connexion WebSocket. La méthode GeneratePDF initialise IronPDF avec une clé de licence et utilise son instance ChromePdfRenderer pour rendre la chaîne hexadécimale en contenu HTML dans un PDF en utilisant la méthode RenderHtmlAsPdf. Vous pouvez obtenir votre clé de licence gratuite depuis ici. Ce PDF est ensuite enregistré localement sous le nom "Data.pdf" en utilisant la méthode SaveAs. L'intégration d'IronPDF permet une conversion sans faille des données dynamiques WebSocket en un format PDF structuré, démontrant son utilité dans la transformation de flux de données en temps réel en documents archivés.
Utiliser Socket.IO avec C# introduit de nombreuses opportunités pour des interactions en temps réel avec des clients connectés, allant au-delà du domaine de JavaScript et Node.js. Intégrer des outils comme Socket.IO et IronPDF dans vos projets .NET peut significativement améliorer la communication en temps réel et les capacités de gestion des PDF. Socket.IO facilite la communication en temps réel et bidirectionnelle transparente entre clients et serveurs, tandis qu'IronPDF offre des fonctionnalités robustes pour créer et manipuler des documents PDF sans effort.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
