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:

DieSocket.IODer Server ist eine leistungsfähige Bibliothek, die 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

DieSocket.IOVerbindung kann mit verschiedenen Low-Level-Transportmethoden 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.

Socket io .NET(Wie es für Entwickler funktioniert): Abbildung 2 - Screenshot, der das Fenster 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, ermöglicht es Web-Clients und -Servern, in Echtzeit zu kommunizieren. 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 inVisual Studio, benötigen Sie eine kompatible Server-Implementierung. Eine solche Implementierung ist das SocketIoClientDotNet für .NET, das es einem Socket IO-Client ermöglicht, von einer C#-Anwendung aus eine Verbindung zu einem Socket.IO herzustellen.

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 für .NET, indem Sie im NuGet-Paketmanager unter 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

Im Ausschnitt erstellen wir zunächst eine Socket.IO-Clientinstanz/-sender, indem wir IO.Socket aufrufen.("https://localhost:3000"), die sich mit dem lokalen Server verbindet, der auf Port 3000 auf dem Client-Computer 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 an den Server, indem wir socket.Emit verwenden.("Nachricht", "Hallo vom C#-Client!"). Dies sendet eine Nachricht mit dem Inhalt "Hallo vom C#-Client!„zum Server.“

Als nächstes hören wir auf Nachrichten vom Server, indem wir einen Callback für das "message"-Ereignis mit socket.On registrieren.("Nachricht"(daten)=>{... }). 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 zur Anzeige der Trennung.

Schließlich die Console.ReadLine()Methode hält 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 (Wie es für Entwickler funktioniert): Abbildung 4 - Beispielcode

HTTP-Long-Polling

Langzeitabfrage ist eine in der Webentwicklung verwendete Technik, die eine Bibliothek verwendet, um Nachrichten zwischen einem Client zu senden.(normalerweise ein Webbrowser)und ein Server. 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(Wie es für Entwickler funktioniert): 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 vorliegen.(z. B. Text oder Binär)und können 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 Bach. 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 die 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 multiplexerten Streams und erweiterten Funktionen.

Hohe Leistung: Gut geeignet für den Aufbau leistungsstarker Webanwendungen, die niedrige Latenzzeiten und zuverlässige Datenübertragung verlangen.

Multiplexe Streams: Unterstützt multiplexe 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 mehr Innovation bei Webkommunikationsprotokollen erwarten.

Verbesserte Benutzererfahrung: Die Einführung 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

IronPDFist eine umfassende .NET PDF-Bibliothek, die speziell für Entwickler entwickelt wurde, die mit C# arbeiten. Dieses leistungsstarke Werkzeug ermöglicht es Entwicklern müheloserstellen, manipulierenundlesenPDF-Dateien in ihren Anwendungen. Mit IronPDF können Entwickler PDF-Dokumente ausHTML-Zeichenfolgen, HTML-DateienundURLs, 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 mit IronPDFUm Bits-Daten 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 über eine WebSocket-Verbindung empfangenen Hexadezimal-String zu erzeugen. 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 von hier. 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, erstellt mit IronPDF

Schlussfolgerung

NutzungSocket.IOmit C# bietet zahlreiche Möglichkeiten für Echtzeitinteraktionen mit verbundenen Clients, die über den Bereich von JavaScript und Node.js hinausgehen. Integrieren von Tools wieSocket.IO undIronPDFin Ihre .NET-Projekte kann die Echtzeitkommunikation und die PDF-Verarbeitungsfähigkeiten erheblich verbessern. Socket.IO ermöglicht nahtlose, bidirektionale Echtzeitkommunikation zwischen Clients und Servern, während IronPDF robuste Funktionen fürerstellung von undmanipulierenPDF-Dokumente mühelos.

IronPDFum sein volles Potenzial freizuschalten und eine effiziente und zuverlässige PDF-Erstellung und -Manipulation in Ihren C#-Anwendungen sicherzustellen.

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