O servidor Socket.IO se destaca como uma biblioteca robusta, que facilita a comunicação bidirecional, em tempo real e orientada a eventos. É amplamente utilizado em aplicações web para tarefas como aplicativos de bate-papo, atualizações em tempo real e plataformas colaborativas. Embora o Socket.IO seja normalmente associado ao JavaScript, ele também pode ser usado de forma eficaz no lado do cliente com C#. Às vezes, o cliente pode ser um navegador da web. Neste artigo, exploraremos como configurar e usar um cliente Socket.IO em um ambiente C#. Analisaremos alguns exemplos básicos e concluiremos com os benefícios e possíveis casos de uso.
Socket.IOA conexão Socket.IO pode ser estabelecida com diferentes transportes de baixo nível:
Long polling HTTP
Web Sockets
Abra o Visual Studio e selecione Criar um novo projeto na janela Iniciar.
Para criar um aplicativo de console no Visual Studio 2022, inicie o Visual Studio e selecione "Criar um novo projeto" na janela inicial. Escolha o modelo "Aplicativo de Console", configure o projeto com um nome e um local e certifique-se de que o .NET 6.0 esteja selecionado.
Socket.IO , uma biblioteca JavaScript , permite que clientes e servidores web se comuniquem em tempo real. É composto por duas partes:
Para usar o Socket.IO em aplicações .NET no Visual Studio , você precisará de uma implementação de servidor compatível. Uma dessas implementações é o SocketIoClientDotNet for .NET, que permite que um cliente Socket.IO se conecte a um Socket.IO a partir de um aplicativo C#.
Primeiro, instale os pacotes NuGet necessários. Você pode fazer isso através do Console do Gerenciador de Pacotes ou adicionando as referências ao seu arquivo de projeto:
A execução deste comando incorporará a biblioteca cliente Socket.IO ao seu projeto .NET , permitindo que seu aplicativo C# se conecte a um servidor Socket.IO, facilitando a comunicação entre os usuários e o sistema.
Antes de mergulharmos no cliente C#, vamos configurar um exemplo básico de Socket IO usando um aplicativo de console .NET Core no Visual Studio. Isso nos ajudará a testar a implementação do cliente.
O código a seguir configura um servidor Socket.IO básico em C# que escuta conexões de clientes na porta 3000. Quando um cliente envia uma mensagem, o servidor registra a mensagem e responde ao cliente, confirmando o recebimento.
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 NamespaceNo trecho, primeiro criamos uma instância de cliente do Socket.IO chamando IO.Socket("http://localhost:3000"), que se conecta ao servidor local em execução na porta 3000 na máquina cliente.
Após a conexão bem-sucedida (Socket.EVENT_CONNECT), imprimimos uma mensagem indicando que estamos conectados ao servidor.
Em seguida, emitimos uma mensagem do cliente para o servidor usando socket.Emit("message", "Hello from C# client!"). Isso envia uma mensagem com o conteúdo "Olá do cliente C#!" para o servidor.
Em seguida, aguardamos mensagens do servidor registrando um retorno de chamada para o evento "message" usando socket.On("message", (data) => { ... }). Quando o servidor envia um evento de "mensagem", a função de retorno de chamada é invocada e imprimimos a mensagem recebida no console.
Se a conexão com o servidor for desconectada do cliente (Socket.EVENT_DISCONNECT), imprimimos uma mensagem indicando a desconexão.
Finalmente, o método Console.ReadLine() mantém a janela do console aberta para que o programa não saia imediatamente após a execução. Isso nos permite visualizar a saída e garante que o programa não seja encerrado prematuramente.
Long-polling é uma técnica usada no desenvolvimento web que emprega uma biblioteca para enviar mensagens entre um cliente (geralmente um navegador web) e um servidor. Ele permite a comunicação em tempo real, acionando eventos no servidor, que podem então ser recebidos pelo cliente sem a necessidade de sondagem contínua. Esse método é particularmente útil para aplicativos que exigem atualizações imediatas, como aplicativos de bate-papo ou cotações da bolsa de valores.
O WebSocket facilita a comunicação bidirecional, estabelecendo canais de comunicação full-duplex sobre uma única conexão TCP. Este protocolo permite a interação em tempo real entre um cliente, normalmente um navegador web, e um servidor, possibilitando que ambas as partes troquem mensagens de forma assíncrona.
O cliente envia uma solicitação de handshake WebSocket ao servidor, indicando seu desejo de estabelecer uma conexão WebSocket. Ao receber a solicitação de handshake, o servidor responde com uma resposta de handshake WebSocket, indicando que a conexão foi estabelecida com sucesso. As mensagens enviadas através da conexão WebSocket podem estar em qualquer formato (por exemplo, texto ou binário) e podem ser enviadas e recebidas de forma assíncrona.
O Web Transport, como um protocolo de ponta, introduz recursos adicionais para aprimorar a comunicação na web, superando as limitações de protocolos tradicionais como TCP e UDP. Ao utilizar UDP e QUIC, ele resolve as deficiências de seus predecessores, tornando-se mais amigável e eficiente. Para os usuários, isso se traduz em menor latência e melhor controle de congestionamento, proporcionando, em última análise, uma experiência na web mais fluida e responsiva. Além disso, o Web Transport oferece melhores medidas de segurança, garantindo uma transmissão de dados mais segura em comparação com o TCP. Com esses avanços, o Web Transport atenua os aspectos demorados da transferência de dados, otimizando o desempenho geral tanto para clientes quanto para servidores.
Aqui está um exemplo básico de como o Web Transport pode ser usado em uma aplicação web:
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 NamespaceNeste exemplo, primeiro criamos uma nova conexão WebSocket para um servidor usando um URL de WebSocket (wss://echo.websocket.org). Em seguida, criamos um fluxo bidirecional sobre a conexão e enviamos alguns dados ([1, 2, 3, 4]) através do fluxo. Por fim, lemos os dados do fluxo e os registramos no console.
Ao executar a aplicação com o servidor de eco WebSocket, a saída deverá ser semelhante a esta:
IronPDF é uma biblioteca PDF .NET abrangente, projetada especificamente para desenvolvedores que trabalham com C#. Essa poderosa ferramenta permite que os desenvolvedores criem , manipulem e leiam arquivos PDF facilmente dentro de seus aplicativos. Com o IronPDF, os desenvolvedores podem gerar documentos PDF a partir de strings HTML , arquivos HTML e URLs , tornando-o altamente versátil para diversos casos de uso. Além disso, o IronPDF oferece recursos avançados de edição de PDF, como a adição de cabeçalhos, rodapés, marcas d'água e muito mais. Sua integração perfeita em projetos C# por meio do gerenciador de pacotes NuGet simplifica o processo de trabalho com arquivos PDF, agilizando o desenvolvimento e aumentando a produtividade.
Instale o IronPDF no Visual Studio ou pela linha de comando usando o Gerenciador de Pacotes NuGet . No Visual Studio, acesse o console:
Aqui está um exemplo simples usando IronPDF para converter dados binários em um arquivo PDF. Chame o método GeneratePDF no método Main e passe os dados como parâmetro que tivemos no exemplo acima:
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
No código fornecido, o IronPDF é usado para gerar um documento PDF a partir de uma string hexadecimal recebida por meio de uma conexão WebSocket. O método GeneratePDF inicializa o IronPDF com uma chave de licença e usa sua instância ChromePdfRenderer para renderizar a string hexadecimal como conteúdo HTML em um PDF usando o método RenderHtmlAsPdf. Você pode obter sua chave de licença gratuita aqui . Este PDF é então salvo localmente como "Data.pdf" usando o método SaveAs. A integração do IronPDF permite a conversão perfeita de dados dinâmicos do WebSocket em um formato PDF estruturado, demonstrando sua utilidade na transformação de fluxos de dados em tempo real em documentos arquiváveis.
A utilização do Socket.IO com C# abre inúmeras oportunidades para interações em tempo real com clientes conectados, indo além do escopo do JavaScript e do Node.js A integração de ferramentas como Socket.IO e IronPDF em seus projetos .NET pode aprimorar significativamente a comunicação em tempo real e os recursos de manipulação de PDFs. O Socket.IO facilita a comunicação bidirecional e em tempo real entre clientes e servidores, enquanto o IronPDF oferece recursos robustos para criar e manipular documentos PDF sem esforço.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
