Serwer Socket.IO jest solidną biblioteką, która ułatwia komunikację w czasie rzeczywistym, dwukierunkową i sterowaną zdarzeniami. Jest szeroko stosowany w aplikacjach internetowych do zadań takich jak aplikacje do czatu, aktualizacje na żywo i platformy współpracy. Chociaż Socket.IO kojarzy się zazwyczaj z JavaScriptem, można go również skutecznie wykorzystywać po stronie klienta w języku C#. Czasami klientem może być przeglądarka internetowa. W tym artykułe omówimy, jak skonfigurować i używać klienta Socket.IO w środowisku C#. Omówimy kilka podstawowych przykładów, a na koniec przedstawimy zalety i potencjalne zastosowania.
Socket.IO polaczenPolaczenie Socket.IO moze byc ustanowione za pomoca roznych niskopoziomowych transportow:
Długie odpytywanie HTTP
Web Sockets
Web Transport
Otwórz program Visual Studio i wybierz opcję Utwórz nowy projekt w oknie Start.
Aby utworzyć aplikację konsolową w Visual Studio 2022, uruchom Visual Studio i wybierz opcję "Utwórz nowy projekt" w oknie startowym. Wybierz szablon "Console App", skonfiguruj projekt, podając nazwę i lokalizację, oraz upewnij się, że wybrano .NET 6.0.
Socket.IO, biblioteka JavaScript, umożliwia klientom i serwerom internetowym komunikację w czasie rzeczywistym. Składa się z dwóch części:
Aby korzystać z Socket.IO w aplikacjach .NET w Visual Studio, potrzebna jest kompatybilna implementacja serwera. Jednym z takich wdrożeń jest SocketIoClientDotNet dla .NET, który umożliwia klientowi Socket.IO połączenie się z Socket.IO z poziomu aplikacji napisanej w języku C#.
Najpierw zainstaluj wymagane pakiety NuGet. Można to zrobić za pomocą konsoli menedżera pakietów lub poprzez dodanie odwołań do pliku projektu:
Wykonanie tego polecenia spowoduje włączenie biblioteki klienckiej Socket.IO do projektu .NET, umożliwiając aplikacji C# połączenie się z serwerem Socket.IO, co ułatwi komunikację między użytkownikami a systemem.
Zanim zagłębimy się w klienta C#, skonfigurujmy podstawowy przykład Socket IO przy użyciu aplikacji konsolowej .NET Core w Visual Studio. Pomoże nam to przetestować wdrożenie klienta.
Poniższy kod konfiguruje podstawowy serwer Socket.IO w języku C#, który nasłuchuje połączeń klientów na porcie 3000. Gdy klient wysyła wiadomość, serwer rejestruje ją i odpowiada klientowi, potwierdzając jej odbiór.
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 NamespaceW tym fragmencie najpierw tworzymy instancje klienta Socket.IO, wywolujac IO.Socket("http://localhost:3000"), ktory laczy sie z lokalnym serwerem dzialajacym na porcie 3000 na maszynie klienckiej.
Po pomyslnym polaczeniu (Socket.EVENT_CONNECT), wyswietlamy komunikat oznaczajacy, ze jestesmy polaczeni z serwerem.
Nastepnie przesylamy wiadomosc z klienta do serwera za pomoca socket.Emit("message", "Hello from C# client!"). Wysyła to do serwera wiadomość o treści "Witaj od klienta C#!".
Następnie nasłuchujemy komunikatów z serwera, rejestrując wywołanie zwrotne dla zdarzenia "message" za pomocą socket.On("message", (data) => { ... }). Gdy serwer wysyła zdarzenie "message", wywoływana jest funkcja wywołania zwrotnego i PRINTujemy otrzymaną wiadomość na konsoli.
Jesli polaczenie z serwerem zostanie przerwane od strony klienta (Socket.EVENT_DISCONNECT), wyswietlamy komunikat oznaczajacy brak polaczenia.
Na koncu metoda Console.ReadLine() utrzymuje otwarte okno konsoli, aby program nie zakonczyl dzialania od razu po wykonaniu. Pozwala nam to zobaczyć wynik i zapewnia, że program nie zakończy działania przedwcześnie.
Long-polling to technika stosowana w tworzeniu stron internetowych, która wykorzystuje bibliotekę do wysyłania komunikatów między klientem (zwykle przeglądarką internetową) a serwerem. Umożliwia komunikację w czasie rzeczywistym poprzez wyzwalanie zdarzeń na serwerze, które mogą być następnie odbierane przez klienta bez konieczności ciągłego odpytywania. Metoda ta jest szczególnie przydatna w przypadku aplikacji wymagających natychmiastowych aktualizacji, takich jak komunikatory internetowe lub serwisy giełdowe.
WebSocket ułatwia komunikację dwukierunkową poprzez ustanowienie kanałów komunikacyjnych typu full-duplex w ramach pojedynczego połączenia TCP. Protokół ten umożliwia interakcję w czasie rzeczywistym między klientem, zazwyczaj przeglądarką internetową, a serwerem, umożliwiając obu stronom asynchroniczną wymianę komunikatów.
Klient wysyła do serwera żądanie nawiązania połączenia WebSocket, sygnalizując chęć ustanowienia połączenia WebSocket. Po otrzymaniu żądania nawiązania połączenia serwer odpowiada komunikatem WebSocket, wskazującym, że połączenie zostało pomyślnie nawiązane. Komunikaty wysyłane przez połączenie WebSocket mogą mieć dowolny format (np. tekstowy lub binarny) i mogą być wysyłane oraz odbierane asynchronicznie.
Web Transport, jako najnowocześniejszy protokół, wprowadza dodatkowe funkcje, które usprawniają komunikację internetową, wykraczając poza ograniczenia tradycyjnych protokołów, takich jak TCP i UDP. Wykorzystując UDP i QUIC, rozwiązuje niedociągnięcia swoich poprzedników, dzięki czemu jest bardziej przyjazny dla użytkownika i wydajny. Dla użytkowników oznacza to mniejsze opóźnienia i lepszą kontrolę przeciążenia, co ostatecznie zapewnia płynniejsze i bardziej responsywne działanie stron internetowych. Ponadto Web Transport oferuje lepsze zabezpieczenia, zapewniając bezpieczniejszy transfer danych w porównaniu z protokołem TCP. Dzięki tym udoskonaleniom Web Transport ogranicza czasochłonne aspekty transferu danych, optymalizując ogólną wydajność zarówno dla klientów, jak i serwerów.
Oto podstawowy przykład wykorzystania Web Transport w aplikacji internetowej:
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 NamespaceW tym przykladzie najpierw tworzymy nowe polaczenie WebSocket z serwerem uzywajac URL WebSocket (wss://echo.websocket.org). Nastepnie tworzymy strumien dwukierunkowy nad polaczeniem i przesylamy pewne dane ([1, 2, 3, 4]) nad strumieniem. Na koniec odczytujemy dane ze strumienia i rejestrujemy je w konsoli.
Po uruchomieniu aplikacji z serwerem echo WebSocket wynik powinien wyglądać mniej więcej tak:
IronPDF to kompleksowa biblioteka .NET do obsługi plików PDF, zaprojektowana specjalnie dla programistów pracujących w języku C#. To potężne narzędzie pozwala programistom bez wysiłku tworzyć, modyfikować i odczytywać pliki PDF w ramach swoich aplikacji. Dzięki IronPDF programiści mogą generować dokumenty PDF na podstawie ciągów znaków HTML, plików HTML i adresów URL, co sprawia, że narzędzie to jest bardzo wszechstronne i nadaje się do różnych zastosowań. Ponadto IronPDF oferuje zaawansowane funkcje edycji plików PDF, takie jak dodawanie nagłówków, stopek, znaków wodnych i wiele innych. Jego płynna integracja z projektami C# za pośrednictwem menedżera pakietów NuGet upraszcza proces pracy z plikami PDF, usprawniając programowanie i zwiększając wydajność.
Zainstaluj IronPDF w Visual Studio lub z wiersza poleceń za pomocą menedżera pakietów NuGet. W programie Visual Studio przejdź do konsoli:
Oto prosty przyklad uzycia IronPDF do konwersji danych binarnych na plik PDF. Wywolaj metode GeneratePDF w metodzie Main i przekaz dane jako parametr, ktory mielismy w powyzszym przykladzie:
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
W podanym kodzie IronPDF służy do generowania dokumentu PDF na podstawie ciągu szesnastkowego otrzymanego przez połączenie WebSocket. Metoda GeneratePDF inicjalizuje IronPDF z kluczem licencyjnym i uzywa instancji ChromePdfRenderer do renderowania ciagu heksadecymalnego jako zawartosci HTML do PDF za pomoca metody RenderHtmlAsPdf. Bezpłatny klucz licencyjny można uzyskać tutaj. Nasrtpienie ten PDF jest zapisywany lokalnie jako "Data.pdf" za pomoca metody SaveAs. Integracja z IronPDF umożliwia płynną konwersję dynamicznych danych WebSocket do ustrukturyzowanego formatu PDF, co pokazuje jego przydatność w przekształcaniu strumieni danych w czasie rzeczywistym w dokumenty archiwalne.
Wykorzystanie Socket.IO w języku C# otwiera wiele możliwości interakcji w czasie rzeczywistym z podłączonymi klientami, wykraczając poza obszar JavaScript i Node.js. Włączenie narzędzi takich jak Socket.IO i IronPDF do projektów .NET może znacznie poprawić komunikację w czasie rzeczywistym oraz możliwości obsługi plików PDF. Socket.IO ułatwia płynną, dwukierunkową komunikację w czasie rzeczywistym między klientami a serwerami, natomiast IronPDF oferuje solidne funkcje do łatwego tworzenia i edycji dokumentów PDF.
Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
