Socket io .NET (Comment ça fonctionne pour les développeurs)

LesSocket.IOserveur se présente comme une bibliothèque robuste, facilitant la communication en temps réel, bidirectionnelle et axée sur les é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 allons parcourir quelques exemples de base et conclure avec les avantages et les cas d'utilisation potentiels.

Méthodes pour établir des connexions Socket.IO

LesSocket.IOla connexion peut être établie avec différents transports de bas niveau :

• Sondage long HTTP

• Web Sockets

  • Transport web

  

Créer un projet de console dans Visual Studio 2022

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é.

Qu'est-ce que Socket.IO ?

Socket.IO, une bibliothèque JavaScript, permet aux clients et serveurs web de communiquer en temps réel. Il se compose de deux parties :

Parties de Socket IO

• Bibliothèque côté client : S'exécute dans le navigateur.
• Bibliothèque côté serveur : Fonctionne sur Node.js.

Installer les paquets nécessaires

Pour utiliser Socket.IO pour des applications .NET dansVisual Studio, vous aurez besoin d'une implémentation serveur compatible. Une telle implémentation est le SocketIoClientDotNet pour .NET, qui permet à un client Socket IO de se connecter à un Socket.IO à partir d'une application C#.

Tout d'abord, installez les packages NuGet nécessaires. Vous pouvez le faire via la console du gestionnaire de packages ou en ajoutant les références à votre fichier de projet.

Install-Package SocketIoClientDotNet

Install-Package SocketIoClientDotNet

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package SocketIoClientDotNet

Capture d'écran du package SocketIoClientDotNet

L'exécution de cette commande intégrera la bibliothèque cliente Socket.IO dans votre projet .NET, permettant à votre application C# de se connecter à un serveur Socket.IO, facilitant ainsi la communication entre les utilisateurs et le système.

Création de Socket.IO

Avant de plonger dans le client C#, configurons un exemple basique de Socket IO en utilisant une application console .NET Core dans Visual Studio. Cela nous aidera à tester l'implémentation client.

Création d'implémentations serveur

Le code suivant configure un serveur Socket.IO basique en C# qui écoute les connexions des clients sur le port 3000. Lorsqu'un client envoie un message, le serveur enregistre le message et répond au client pour confirmer 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();
        }
    }
}

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 Namespace

Explication du code

Dans l'extrait, nous créons d'abord une instance/client Socket.IO en appelant IO.Socket("https://localhost:3000"), qui se connecte au serveur local fonctionnant sur le port 3000 sur la machine client.

Après une connexion réussie(Socket.EVENT_CONNECT), nous affichons un message indiquant que nous sommes connectés au serveur.

Ensuite, nous émettons un message d'un client vers le serveur en utilisant socket.Emit.("message", "Bonjour du client C#"!"). Cela envoie un message avec le contenu "Bonjour depuis le client C#"!" vers le serveur.

Ensuite, nous écoutons les messages du serveur en enregistrant un rappel pour l'événement "message" en utilisant socket.On.("message"(données) => {... }). Lorsque le serveur envoie un événement "message", la fonction de rappel est invoquée, et nous affichons le message reçu sur la console.

Si la connexion au serveur est déconnectée du client(Socket.EVENT_DISCONNECT)nous affichons un message indiquant la déconnexion.

Enfin, le Console.ReadLine()La méthode garde la fenêtre de la console ouverte afin que le programme ne se ferme pas immédiatement après l'exécution. Cela nous permet de voir la sortie et garantit que le programme ne se termine pas prématurément.

Capture d'écran du code

Sondage long HTTP

Le long-polling est une technique utilisée dans le développement web qui emploie une bibliothèque pour envoyer des messages entre un client(généralement un navigateur web)et un serveur. Il permet la communication en temps réel en déclenchant des événements sur le serveur, qui peuvent ensuite être reçus par le client sans la nécessité de sondages continus. Cette méthode est particulièrement utile pour les applications nécessitant des mises à jour immédiates, telles que les applications de messagerie instantanée ou les téléscripteurs boursiers.

Sockets Web

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.

Établir une communication WebSocket

Le client envoie une requête de poignée de main WebSocket au serveur, indiquant son désir d'établir une connexion WebSocket. À la réception de la demande de poignée de main, le serveur répond avec 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.

Transport web

Le protocole Web Transport, en tant que protocole de pointe, introduit des fonctionnalités supplémentaires pour améliorer la communication web au-delà des limites des protocoles traditionnels comme TCP et UDP. En tirant parti de UDP et QUIC, il remédie aux insuffisances de ses prédécesseurs, le rendant ainsi 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é, garantissant une transmission des 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 ainsi la performance globale pour les clients et les serveurs.

Voici un exemple de base de l'utilisation de Web Transport dans une application web :

using System;
using System.Net.WebSockets;
using System.Text;
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));
            }
        }
    }
}

using System;
using System.Net.WebSockets;
using System.Text;
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.Text
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 Namespace

Dans cet exemple, nous créons d'abord une nouvelle connexion WebTransport à un serveur en utilisant une URL WebSocket.(wss://echo.websocket.org). Ensuite, nous créons un flux bidirectionnel sur la connexion et envoyons des données.([1, 2, 3, 4])au-dessus du ruisseau. Enfin, nous lisons les données du flux et les enregistrons dans la console.

Sortie du code ci-dessus

Lorsque vous exécutez l'application avec le serveur WebSocket echo, la sortie devrait ressembler à ceci :

Avantages du transport Web

Alternative Moderne : Web Transport offre une alternative moderne aux protocoles de communication web traditionnels tels que TCP et UDP.

Transfert de données efficace : Il propose un transfert de données efficace en utilisant des flux multiplexés et des fonctionnalités avancées.

Haute Performance : Bien adapté pour développer des applications web haute performance nécessitant une faible latence et un transfert de données fiable.

Flux multiplexés : Prend en charge les flux multiplexés, permettant à plusieurs flux de données d'être envoyés et reçus simultanément sur une seule connexion.

Innovation : À mesure que les développeurs web continuent d'adopter Web Transport, nous pouvons nous attendre à voir plus d'innovation dans les protocoles de communication web.

Expérience utilisateur améliorée : L'adoption de Web Transport peut conduire à des expériences utilisateur améliorées sur le web grâce à un transfert de données plus rapide et plus fiable.

Présentation de la bibliothèque IronPDF

IronPDFest une bibliothèque PDF complète pour .NET spécialement conçue pour les développeurs travaillant avec C#. Cet outil puissant permet aux développeurs de créer sans effortcréer, manipuleretlireFichiers PDF au sein de leurs applications. Avec IronPDF, les développeurs peuvent générer des documents PDF à partir deChaînes HTML, Fichiers HTMLetURL, ce qui le rend très polyvalent pour divers cas d'utilisation. De plus, IronPDF offre des fonctionnalités avancées d'édition PDF telles que 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 gestionnaire de packages NuGet simplifie le processus de travail avec les fichiers PDF, rationalisant le développement et améliorant la productivité.

Installation avec NuGet Package Manager

Installez IronPDF dans Visual Studio ou à partir de la ligne de commande en utilisant le gestionnaire de packages NuGet. Dans Visual Studio, allez à la console :

• Outils -> NuGet Package Manager -> Console du gestionnaire de paquets

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Exemple de code IronPDF

Voici un exemple simple utilisantIronPDFpour convertir des données bits en un fichier PDF, appelez la méthode GeneratePDF dans la méthode Main et passez les données en paramètre comme dans l'exemple ci-dessus.

using System;
using System.Net.WebSockets;
using System.Text;
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);
         }
     }
 }
}

using System;
using System.Net.WebSockets;
using System.Text;
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.Text
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 Namespace

Code de la classe de génération de PDF

using 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(data);
          string filePath = "Data.pdf";
          pdf.SaveAs(filePath);
          Console.WriteLine($"PDF Generation Completed,File Saved as ${filePath}");
        }
    }
}

using 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(data);
          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(data)
		  Dim filePath As String = "Data.pdf"
		  pdf.SaveAs(filePath)
		  Console.WriteLine($"PDF Generation Completed,File Saved as ${filePath}")
		End Sub
	End Class
End Namespace

Sortie

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 tant que 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 fluide des données WebSocket dynamiques en un format PDF structuré, démontrant son utilité dans la transformation des flux de données en temps réel en documents d'archivage.

Fichier PDF généré

Conclusion

UtilisationSocket.IOavec C# introduit de nombreuses opportunités pour des interactions en temps réel avec des clients connectés, s'étendant au-delà du domaine de JavaScript et de Node.js. Intégrer des outils commeSocket.IO etIronPDFdans vos projets .NET peut améliorer considérablement les capacités de communication en temps réel et de gestion des PDF. Socket.IO facilite une communication bidirectionnelle en temps réel fluide entre les clients et les serveurs, tandis que IronPDF offre des fonctionnalités robustes pourcréer etmanipulerDocuments PDF sans effort.

IronPDFpour libérer tout son potentiel, assurant une génération et une manipulation de PDF efficaces et fiables dans vos applications C#.