Socket io .NET (Wie es für Entwickler funktioniert)

Socket.IO, eine JavaScript-Bibliothek, befähigt Webclients und -server zur Echtzeitkommunikation. Es besteht aus zwei Teilen:

Bestandteile von Socket IO

• Bibliothek auf der Client-Seite: Läuft im Browser.
• Bibliothek auf der Server-Seite: Läuft unter Node.js.

Installieren Sie die erforderlichen Pakete

Um Socket.IO für .NET-Anwendungen in Visual Studio zu verwenden, benötigen Sie eine kompatible Serverimplementierung. Eine solche Implementierung ist das SocketIoClientDotNet für .NET, das es einem Socket.IO-Client ermöglicht, sich mit einem Socket.IO von einer C#-Anwendung zu verbinden.

Installieren Sie zuerst die erforderlichen NuGet-Pakete. Dies können Sie über die Package Manager Console oder durch Hinzufügen der Referenzen zu Ihrer Projektdatei tun:

Install-Package SocketIoClientDotNet

Screenshot des SocketIoClientDotNet-Pakets

Durch das Ausführen dieses Befehls wird die Socket.IO-Client-Bibliothek in Ihr .NET-Projekt einbezogen, wodurch Ihre C#-Anwendung mit einem Socket.IO-Server verbunden werden kann und die Kommunikation zwischen Benutzern und dem System erleichtert wird.

Bevor wir uns mit dem C#-Client befassen, richten wir ein einfaches Beispiel von Socket IO mithilfe von .NET Core Console App in Visual Studio ein. Dies wird uns helfen, die Client-Implementierung zu testen.

Erstellen von Server-Implementierungen

Der folgende Code richtet einen grundlegenden Socket.IO-Server in C# ein, der auf Client-Verbindungen auf Port 3000 hört. Wenn ein Client eine Nachricht sendet, protokolliert der Server die Nachricht und antwortet dem Client zurück, um den Empfang zu bestätigen.

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

Codeerklärung

Im Code-Snippet erstellen wir zunächst eine Socket.IO-Clientinstanz durch Aufruf von IO.Socket("http://localhost:3000"), die eine Verbindung zum lokalen Server herstellt, der auf Port 3000 auf dem Client-Rechner läuft.

Nach erfolgreicher Verbindung (Socket.EVENT_CONNECT) geben wir eine Meldung aus, die anzeigt, dass wir mit dem Server verbunden sind.

Dann senden wir eine Nachricht vom Client an den Server mit socket.Emit("message", "Hello from C# client!"). Dies sendet eine Nachricht mit dem Inhalt "Hello from C# client!" an den Server.

Als nächstes hören wir auf Nachrichten vom Server, indem wir einen Callback für das "message"-Ereignis mit socket.On("message", (data) => { ... }). Wenn der Server ein "message"-Ereignis sendet, wird die Callback-Funktion aufgerufen und wir geben die empfangene Nachricht in der Konsole aus.

Wenn die Verbindung zum Server vom Client getrennt wird (Socket.EVENT_DISCONNECT), geben wir eine Meldung aus, die die Trennung anzeigt.

Schließlich sorgt die Methode Console.ReadLine() dafür, dass das Konsolenfenster geöffnet bleibt, damit das Programm nicht unmittelbar nach der Ausführung beendet wird. Dies ermöglicht uns, die Ausgabe zu sehen und stellt sicher, dass das Programm nicht vorzeitig beendet wird.

Screenshot des Codes

Installieren Sie IronPDF in Visual Studio oder von der Befehlszeile aus mithilfe des NuGet-Paket-Managers. Gehen Sie in Visual Studio zur Konsole:

• Tools -> NuGet-Paket-Manager -> Paket-Manager-Konsole

Install-Package IronPdf

IronPDF Code-Beispiel

Hier ist ein einfaches Beispiel, wie man mit IronPDF Binärdaten in eine PDF-Datei konvertiert. Rufen Sie die Methode GeneratePDF in der Methode Main auf und übergeben Sie die Daten als Parameter, die wir im obigen Beispiel verwendet haben:

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);
            }
        }
    }
}

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 Namespace

PDF-Erzeugung Klassencode

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($"<h1>Received Data</h1><p>{data}</p>");
            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($"<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