1. IronPDF
  2. IronPDF-Blog
  3. .NET-Hilfe
  4. Socket io .NET
.NET-HILFE

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

Chipego
Chipego Kalinda
29. September 2024
Teilen Sie:

Der Socket.IO Server ist eine robuste Bibliothek, die Echtzeit-, bidirektionale und ereignisgesteuerte Kommunikation ermöglicht. Es wird häufig in Webanwendungen für Aufgaben wie Chat-Anwendungen, Live-Aktualisierungen und kollaborative Plattformen verwendet. Obwohl Socket.IO typischerweise mit JavaScript in Verbindung gebracht 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 einfache Beispiele durchgehen und mit den Vorteilen und potenziellen Anwendungsfällen abschließen.

Methoden zur Erstellung von Socket.IO-Verbindungen

Die Socket.IO-Verbindung kann mit verschiedenen Low-Level-Transporten hergestellt werden:

  • HTTP-Long-Polling

  • WebSockets

    • Webtransport

    Socket io .NET (Wie es für Entwickler funktioniert): Abbildung 1 - Client-Server-Kommunikationsanwendung

Erstellen eines Konsolenprojekts in Visual Studio 2022

Öffnen Sie Visual Studio und wählen Sie im Startfenster Neues Projekt erstellen aus.

Socket io .NET (Wie es für Entwickler funktioniert): Abbildung 2 - Screenshot, der das Fenster Ein neues Projekt erstellen zeigt.

Um eine Konsolenanwendung in Visual Studio 2022 zu erstellen, starten Sie Visual Studio und wählen Sie im Startfenster "Create a new project" aus. Wählen Sie die Vorlage "Konsolenanwendung", konfigurieren Sie das Projekt mit einem Namen und Speicherort und stellen Sie sicher, dass .NET 6.0 ausgewählt ist.

Was ist Socket.IO?

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

Teile von Socket IO

  • Clientseitige Bibliothek: Läuft im Browser.
  • Serverseitige Bibliothek: Läuft auf Node.js.

Installieren Sie die notwendigen Pakete

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

Zuerst die notwendigen NuGet-Pakete installieren. Sie können dies über die Paket-Manager-Konsole oder durch Hinzufügen der Referenzen zu Ihrer Projektdatei tun.

Install-Package SocketIoClientDotNet
Install-Package SocketIoClientDotNet

Screenshot des SocketIoClientDotNet-Pakets

Socket io .NET (Wie es für Entwickler funktioniert): Abbildung 3 - Installieren Sie Socket.IO for NET, indem Sie das NuGet-Paket für die Lösung verwalten und im Suchfeld des NuGet-Paket-Managers nach dem Paketnamen SocketIoClientDotNet suchen, wählen Sie dann das Projekt aus und klicken Sie auf die Schaltfläche Installieren.

Die Ausführung dieses Befehls wird die Socket.IO-Client-Bibliothek in Ihr .NET-Projekt integrieren, wodurch Ihre C#-Anwendung mit einem Socket.IO-Server verbunden werden kann, um die Kommunikation zwischen Benutzern und dem System zu ermöglichen.

Erstellen von Socket.IO

Bevor wir uns mit dem C#-Client beschäftigen, richten wir ein einfaches Beispiel von Socket IO mit einer .NET Core-Konsolenanwendung in Visual Studio ein. Dies wird uns helfen, die Implementierung des Clients zu testen.

Erstellen von Serverimplementierungen

Der folgende Code richtet einen grundlegenden Socket.IO-Server in C# ein, der auf Port 3000 auf Clientverbindungen hört. Wenn ein Client eine Nachricht sendet, protokolliert der Server die Nachricht und antwortet dem Client, 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();
        }
    }
}

Code Erläuterung

In dem Code-Snippet erstellen wir zuerst eine Socket.IO-Clientinstanz/-Sender, indem wir IO.Socket("https://localhost:3000") aufrufen, die eine Verbindung zum lokalen Server herstellt, der auf Port 3000 auf dem Client-Rechner läuft.

Bei erfolgreicher Verbindung (Socket.EVENT_CONNECT) drucken wir eine Nachricht, die anzeigt, dass wir mit dem Server verbunden sind.

Dann senden wir eine Nachricht von einem Client zum Server, indem wir socket.Emit("message", "Hello from C# client!") verwenden. 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 registrieren, indem wir socket.On("message", (data) => { ... }). Wenn der Server ein "message"-Ereignis sendet, wird die Callback-Funktion aufgerufen und wir drucken die empfangene Nachricht in die Konsole.

Wenn die Verbindung zum Server vom Client getrennt wird (Socket.EVENT_DISCONNECT), drucken wir eine Nachricht, die die Trennung anzeigt.

Abschließend hält die Methode Console.ReadLine() das Konsolenfenster offen, damit das Programm nicht sofort nach der Ausführung beendet wird. Dadurch können wir die Ausgabe sehen und sicherstellen, dass das Programm nicht vorzeitig beendet wird.

Screenshot des Codes

Socket io .NET (So funktioniert es für Entwickler): Abbildung 4 - Beispielcode

HTTP-Long-Polling

Long-Polling ist eine in der Webentwicklung verwendete Technik, die eine Bibliothek einsetzt, um Nachrichten zwischen einem Client (in der Regel ein Webbrowser) und einem Server zu senden. Es ermöglicht Echtzeitkommunikation, indem Ereignisse auf dem Server ausgelöst werden, 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 zum Beispiel Chat-Anwendungen oder Börsenticker.

Socket io .NET (So funktioniert es für Entwickler): Abbildung 5 - HTTP-Long-Polling

Websockets

WebSocket ermöglicht bidirektionale Kommunikation, indem es voll-duplex Kommunikationskanäle über eine einzelne TCP-Verbindung einrichtet. Dieses Protokoll ermöglicht die Echtzeit-Interaktion zwischen einem Client, typischerweise einem Webbrowser, und einem Server, wodurch beide Parteien in der Lage sind, Nachrichten asynchron auszutauschen.

Einrichtung der WebSocket-Kommunikation

Der Client sendet eine WebSocket-Handshake-Anfrage an den Server, um seinen Wunsch nach einer WebSocket-Verbindung zu signalisieren. 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 (z. B. Text oder Binärdaten) vorliegen und asynchron gesendet und empfangen werden.

Webtransport

Web Transport, als ein hochmodernes Protokoll, führt zusätzliche Funktionen ein, um die Webkommunikation über die Einschränkungen traditioneller Protokolle wie TCP und UDP hinaus zu verbessern. Durch die Nutzung von UDP und QUIC behebt es die Mängel seiner Vorgänger und macht es benutzerfreundlicher und effizienter. Für die Benutzer bedeutet dies eine reduzierte Latenz und verbesserte Staukontrolle, was letztlich zu einem reibungsloseren und reaktionsfähigeren Web-Erlebnis führt. Darüber hinaus bietet Web Transport bessere Sicherheitsmaßnahmen, die eine sicherere Datenübertragung im Vergleich zu TCP gewährleisten. Mit diesen Fortschritten mindert Web Transport die zeitraubenden Aspekte der Datenübertragung und optimiert die Gesamtleistung sowohl für Clients als auch für Server.

Hier ist ein einfaches Beispiel dafür, wie Web Transport in einer Webanwendung verwendet werden kann:

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

In diesem Beispiel erstellen wir zunächst eine neue WebTransport Verbindung zu einem Server unter Verwendung 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.

Ausgabe des obigen Codes

Wenn Sie die Anwendung mit dem WebSocket-Echo-Server ausführen, sollte die Ausgabe in etwa so aussehen:

Socket io .NET (Wie es für Entwickler funktioniert): Abbildung 6 - Konsolenausgabe für WebTransport-Verbindung unter Verwendung einer WebSocket-URL.

Vorteile von Web Transport

Moderne Alternative: Web Transport bietet eine moderne Alternative zu traditionellen Webkommunikationsprotokollen wie TCP und UDP.

Effiziente Datenübertragung: Es bietet eine effiziente Datenübertragung durch die Nutzung von multiplexierten Streams und fortschrittlichen Funktionen.

Hohe Leistung: Gut geeignet für den Aufbau von Hochleistungs-Webanwendungen, die geringe Latenz und zuverlässige Datenübertragung erfordern.

Multiplexed Streams: Unterstützt multiplexierte Streams, die es ermöglichen, mehrere Datenströme gleichzeitig über eine einzelne Verbindung zu senden und zu empfangen.

Innovation: Da Webentwickler weiterhin Web Transport übernehmen, können wir mit mehr Innovationen in den Web-Kommunikationsprotokollen rechnen.

Verbesserte Benutzererfahrung: Die Nutzung von Web Transport kann zu verbesserten Benutzererfahrungen im Web führen, da Daten schneller und zuverlässiger übertragen werden.

Einführung in die IronPDF-Bibliothek

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, bearbeiten und lesen. Mit IronPDF können Entwickler PDF-Dokumente aus HTML-Strings, HTML-Dateien und URLs erzeugen, was es für verschiedene Anwendungsfälle äußerst vielseitig macht. Darüber hinaus bietet IronPDF erweiterte PDF-Bearbeitungsfunktionen wie das Hinzufügen von Kopfzeilen, Fußzeilen, Wasserzeichen und vieles mehr. Die nahtlose Integration in C#-Projekte über den NuGet-Paketmanager vereinfacht den Umgang mit PDF-Dateien, rationalisiert die Entwicklung und steigert die Produktivität.

Socket io .NET (Wie es für Entwickler funktioniert): Abbildung 7 - IronPDF for .NET: Die C# PDF Bibliothek

Installation mit NuGet-Paketmanager

Installieren Sie IronPDF in Visual Studio oder über die Befehlszeile mit dem NuGet-Paket-Manager. In Visual Studio, gehen Sie zur Konsole:

  • Werkzeuge -> NuGet-Paketmanager -> Paketmanager-Konsole
Install-Package IronPdf
Install-Package IronPdf

IronPDF Codebeispiel

Hier ist ein einfaches Beispiel, das IronPDF verwendet, um Datenfragmente in eine PDF-Datei zu konvertieren. Rufen Sie die Methode GeneratePDF 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.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);
         }
     }
 }
}

PDF-Generierungsklasse Code

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

Ausgabe

Socket io .NET (Wie es für Entwickler funktioniert): Abbildung 8 - Konsolenausgabe mit Socket.IO und IronPDF

Im bereitgestellten Code wird IronPDF verwendet, um ein PDF-Dokument aus einem hexadezimalen String zu erzeugen, der über eine WebSocket-Verbindung empfangen wird. Die GeneratePDF-Methode initialisiert IronPDF mit einem Lizenzschlüssel und verwendet die ChromePdfRenderer-Instanz, um die hexadezimale Zeichenfolge als HTML-Inhalt in ein PDF zu rendern, indem die RenderHtmlAsPdf-Methode eingesetzt wird. Sie können Ihren kostenlosen Lizenzschlüssel 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 damit seine Nützlichkeit bei der Umwandlung von Echtzeit-Datenströmen in Archivdokumente.

PDF-Datei generiert

Socket io .NET (Wie es für Entwickler funktioniert): Abbildung 9 - Ausgabepdf generiert mit IronPDF

Schlussfolgerung

Die Nutzung von Socket.IO mit C# bietet zahlreiche Möglichkeiten für Echtzeit-Interaktionen 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 Echtzeitkommunikations- und PDF-Verarbeitungsfähigkeiten erheblich verbessern. Socket.IO ermöglicht nahtlose Echtzeitkommunikation in beide Richtungen zwischen Clients und Servern, während IronPDF robuste Funktionen zum Erstellen und Bearbeiten von PDF-Dokumenten mühelos bietet.

IronPDF, um das volle Potenzial freizuschalten und eine effiziente und zuverlässige PDF-Erstellung und -Bearbeitung in Ihren C#-Anwendungen zu gewährleisten.

Chipego
Chipego Kalinda
  Jetzt mit dem Ingenieurteam chatten
Software-Ingenieur
Chipego hat eine natürliche Fähigkeit zum Zuhören, die ihm hilft, Kundenprobleme zu verstehen und intelligente Lösungen anzubieten. Er trat dem Iron Software-Team 2023 bei, nachdem er einen Bachelor of Science in Informationstechnologie erworben hatte. IronPDF und IronOCR sind die beiden Produkte, auf die sich Chipego konzentriert hat, aber sein Wissen über alle Produkte wächst täglich, da er neue Wege findet, Kunden zu unterstützen. Er genießt die Zusammenarbeit bei Iron Software, da Teammitglieder aus dem gesamten Unternehmen ihre unterschiedlichen Erfahrungen einbringen und so zu effektiven, innovativen Lösungen beitragen. Wenn Chipego nicht an seinem Schreibtisch sitzt, kann man ihn oft bei einem guten Buch oder beim Fußballspielen antreffen.
< PREVIOUS
C# foreach mit Index (Wie es für Entwickler funktioniert)
NÄCHSTES >
JUnit Java (Wie es für Entwickler funktioniert)

Ein Problem melden

Sind Sie bereit, loszulegen? Version: 2025.4 gerade veröffentlicht

Kostenloser Start
NuGet herunterladen DLL herunterladen Windows-Installationsprogramm Kostenlos testen
Lizenzen anzeigen >
Textlogo Iron Suite related to Socket io .NET (Wie es für Entwickler funktioniert)

IronPDF ist ein Teil von IRONSUITE

10 .NET API-Produkte für Ihre Bürodokumente

Erhalten Sie 10 Produkte zum Preis von 2   Kostenlos testen