Der Socket.IO-Server erweist sich als robuste Bibliothek, die Echtzeit-, bidirektionale und ereignisgesteuerte Kommunikation erleichtert. Er wird häufig in Webanwendungen für Aufgaben wie Chat-Anwendungen, Live-Updates und kollaborative Plattformen verwendet. Auch wenn Socket.IO typischerweise mit JavaScript assoziiert wird, kann es auch effektiv auf der Client-Seite mit C# verwendet werden. Manchmal kann der Client ein Webbrowser sein. In diesem Artikel werden wir untersuchen, wie man einen Socket.IO-Client in einer C#-Umgebung einrichtet und verwendet. Wir werden einige grundlegende Beispiele durchgehen und mit den Vorteilen und potenziellen Anwendungsfällen abschließen.
Socket.IO-VerbindungenDie Socket.IO-Verbindung kann mit verschiedenen Low-Level-Transporten hergestellt werden:
HTTP Long-Polling
Web Sockets
Öffnen Sie Visual Studio und wählen Sie im Startfenster Neues Projekt erstellen aus.
Um eine Konsolenanwendung in Visual Studio 2022 zu erstellen, starten Sie Visual Studio und wählen Sie "Neues Projekt erstellen" aus dem Startfenster. Wählen Sie die Vorlage "Konsolenanwendung" aus, konfigurieren Sie das Projekt mit einem Namen und einem Speicherort und stellen Sie sicher, dass .NET 6.0 ausgewählt ist.
Socket.IO, eine JavaScript-Bibliothek, befähigt Webclients und -server zur Echtzeitkommunikation. Es besteht aus zwei Teilen:
Um Socket.IO for .NET-Anwendungen in Visual Studio zu verwenden, benötigen Sie eine kompatible Serverimplementierung. Eine solche Implementierung ist das SocketIoClientDotNet for .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:
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.
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();
}
}
}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 NamespaceIm Code-Beispiel erstellen wir zuerst eine Socket.IO-Client-Instanz, indem wir IO.Socket("http://localhost:3000") aufrufen, die sich mit dem lokal auf Port 3000 laufenden Server auf dem Client-Computer verbindet.
Bei erfolgreicher Verbindung (Socket.EVENT_CONNECT) wird eine Nachricht gedruckt, die angibt, 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), drucken wir eine Nachricht, die die Trennung anzeigt.
Schließlich hält die Console.ReadLine()-Methode das Konsolenfenster offen, sodass das Programm nicht sofort nach der Ausführung beendet wird. Dies ermöglicht uns, die Ausgabe zu sehen und stellt sicher, dass das Programm nicht vorzeitig beendet wird.
Long-Polling ist eine Technik der Webentwicklung, die eine Bibliothek verwendet, um Nachrichten zwischen einem Client (normalerweise ein Webbrowser) und einem Server zu senden. Es ermöglicht Echtzeitkommunikation durch das Auslösen von Ereignissen auf dem Server, die dann vom Client ohne ständiges Abfragen empfangen werden können. Diese Methode ist besonders nützlich für Anwendungen, die sofortige Aktualisierungen erfordern, wie Chat-Anwendungen oder Börsenticker.
WebSocket ermöglicht bidirektionale Kommunikation durch das Einrichten von Voll-Duplex-Kommunikationskanälen über eine einzige TCP-Verbindung. Dieses Protokoll ermöglicht Echtzeitinteraktionen zwischen einem Client, typischerweise ein Webbrowser, und einem Server, wodurch beide Parteien asynchron Nachrichten austauschen können.
Der Client sendet eine WebSocket-Handshake-Anforderung an den Server, um sein Verlangen zu signalisieren, eine WebSocket-Verbindung herzustellen. Nach Erhalt der Handshake-Anfrage antwortet der Server mit einer WebSocket-Handshake-Antwort, die anzeigt, dass die Verbindung erfolgreich hergestellt wurde. Die über die WebSocket-Verbindung gesendeten Nachrichten können in jedem Format vorliegen (z. B. Text oder Binär) und können asynchron gesendet und empfangen werden.
Web Transport, als fortschrittliches Protokoll, führt zusätzliche Funktionen ein, um die Webkommunikation über die Grenzen traditioneller Protokolle wie TCP und UDP hinaus zu verbessern. Durch die Nutzung von UDP und QUIC behebt es die Schwächen seiner Vorgänger und macht es benutzerfreundlicher und effizienter. Für Benutzer bedeutet dies reduzierte Latenz und verbesserte Staukontrolle, was letztendlich eine glattere und reagierfähigere Web-Erfahrung bietet. Darüber hinaus bietet Web Transport bessere Sicherheitsmaßnahmen und gewährleistet eine sicherere Datenübertragung im Vergleich zu TCP. Mit diesen Fortschritten mindert Web Transport die zeitaufwändigen Aspekte der Datenübertragung und optimiert die Gesamtleistung sowohl für Clients als auch für Server.
Hier ist ein einfaches Beispiel, wie Web Transport in einer Webanwendung verwendet werden kann:
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 NamespaceIn diesem Beispiel erstellen wir zuerst eine neue WebSocket-Verbindung zu einem Server mit einer WebSocket-URL (wss://echo.websocket.org). Dann erstellen wir einen bidirektionalen Stream über die Verbindung und senden einige Daten ([1, 2, 3, 4]) über den Stream. Schließlich lesen wir Daten aus dem Stream und protokollieren sie in der Konsole.
Wenn Sie die Anwendung mit dem WebSocket-Echo-Server ausführen, sollte die Ausgabe so aussehen wie diese:
IronPDF ist eine umfassende .NET PDF-Bibliothek, die speziell für Entwickler entwickelt wurde, die mit C# arbeiten. Dieses leistungsstarke Werkzeug ermöglicht es Entwicklern, mühelos PDF-Dateien innerhalb ihrer Anwendungen zu erstellen, manipulieren und lesen. Mit IronPDF können Entwickler PDF-Dokumente aus HTML-Strings, HTML-Dateien und URLs generieren, was es für verschiedene Anwendungsfälle sehr vielseitig macht. Darüber hinaus bietet IronPDF erweiterte PDF-Bearbeitungsfunktionen wie das Hinzufügen von Kopf- und Fußzeilen, Wasserzeichen und vieles mehr. Die nahtlose Integration in C#-Projekte über den NuGet Package Manager vereinfacht die Arbeit mit PDF-Dateien, strafft die Entwicklung und erhöht die Produktivität.
Installieren Sie IronPDF in Visual Studio oder von der Befehlszeile aus mithilfe des NuGet-Paket-Managers. Gehen Sie in Visual Studio zur Konsole:
Hier ist ein einfaches Beispiel, das IronPDF verwendet, um Binärdaten in eine PDF-Datei umzuwandeln. Rufen Sie die GeneratePDF-Methode in der Main-Methode auf und übergeben Sie die Daten als Parameter, die wir im obigen Beispiel hatten:
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
Im bereitgestellten Code wird IronPDF verwendet, um ein PDF-Dokument aus einem hexadezimalen String zu generieren, der über eine WebSocket-Verbindung empfangen wird. Die GeneratePDF-Methode initialisiert IronPDF mit einem Lizenzschlüssel und verwendet seine ChromePdfRenderer-Instanz, um die hexadezimale Zeichenkette als HTML-Inhalt in ein PDF zu rendern, indem sie die RenderHtmlAsPdf-Methode verwendet. Sie können Ihren kostenlosen Lizenzschlüssel von hier erhalten. Dieses PDF wird dann lokal als "Data.pdf" mit der SaveAs-Methode gespeichert. Die Integration von IronPDF ermöglicht die nahtlose Umwandlung von dynamischen WebSocket-Daten in ein strukturiertes PDF-Format und demonstriert so seine Nützlichkeit bei der Umwandlung von Echtzeitdatenströmen in Archivdokumente.
Die Verwendung von Socket.IO mit C# eröffnet zahlreiche Möglichkeiten für Echtzeitinteraktionen mit verbundenen Clients und geht über den Bereich von JavaScript und Node.js hinaus. Die Integration von Tools wie Socket.IO und IronPDF in Ihre .NET-Projekte kann die Echtzeitkommunikation und die PDF-Verarbeitung erheblich verbessern. Socket.IO erleichtert nahtlose Echtzeit-, bidirektionale Kommunikation zwischen Clients und Servern, während IronPDF robuste Funktionen zum Erstellen und Bearbeiten von PDF-Dokumenten mühelos bietet.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
