Socket io .NET (Cómo funciona para desarrolladores)

EnSocket.IOEl servidor se presenta como una biblioteca robusta, facilitando la comunicación en tiempo real, bidireccional y dirigida por eventos. Se utiliza ampliamente en aplicaciones web para tareas como aplicaciones de chat, actualizaciones en vivo y plataformas colaborativas. Aunque Socket.IO se asocia típicamente con JavaScript, también se puede usar de manera efectiva en el lado del cliente con C#. A veces el cliente puede ser un navegador web. En este artículo, exploraremos cómo configurar y utilizar un cliente Socket.IO en un entorno C#. Vamos a revisar algunos ejemplos básicos y concluiremos con los beneficios y casos de uso potenciales.

Métodos para Establecer Conexiones Socket.IO

EnSocket.IOse puede establecer conexión con diferentes transportes de bajo nivel:

• HTTP long-polling

• Web Sockets

  • Transporte Web

  

Creando un proyecto de consola en Visual Studio 2022

Abre Visual Studio y selecciona Crear un nuevo proyecto en la ventana de inicio.

Para crear una aplicación de consola en Visual Studio 2022, inicie Visual Studio y seleccione "Crear un nuevo proyecto" desde la ventana de inicio. Elija la plantilla "Aplicación de consola", configure el proyecto con un nombre y ubicación, y asegúrese de que .NET 6.0 esté seleccionado.

¿Qué es Socket.IO?

Socket.IO, una biblioteca de JavaScript, permite a los clientes y servidores web comunicarse en tiempo real. Consiste en dos partes:

Partes de Socket IO

• Biblioteca del lado del cliente: Se ejecuta en el navegador.
• Biblioteca del lado del servidor: Funciona en Node.js.

Instalar los paquetes necesarios

Para usar Socket.IO en aplicaciones .NET enVisual Studio, necesitarás una implementación de servidor compatible. Una de esas implementaciones es SocketIoClientDotNet para .NET, que permite a un cliente Socket IO conectarse a un Socket.IO desde una aplicación C#.

Primero, instala los paquetes NuGet requeridos. Puede hacerlo a través de la Consola del Administrador de Paquetes o agregando las referencias a su archivo de proyecto.

Install-Package SocketIoClientDotNet

Install-Package SocketIoClientDotNet

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package SocketIoClientDotNet

Captura de pantalla del paquete SocketIoClientDotNet

Ejecutar este comando incorporará la biblioteca cliente de Socket.IO en tu proyecto .NET, permitiendo que tu aplicación C# se conecte con un servidor Socket.IO, facilitando la comunicación entre los usuarios y el sistema.

Creando Socket.IO

Antes de sumergirnos en el cliente C#, configuremos un ejemplo básico de Socket IO usando una aplicación de consola .NET Core en Visual Studio. Esto nos ayudará a probar la implementación del cliente.

Creando implementaciones de servidor

El siguiente código configura un servidor Socket.IO básico en C# que escucha las conexiones de los clientes en el puerto 3000. Cuando un cliente envía un mensaje, se registra el mensaje y se responde al cliente, confirmando la recepción.

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

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 Namespace

Código Explicación

En el fragmento, primero creamos una instancia de cliente/emisor de Socket.IO llamando a IO.Socket("https://localhost:3000"), que se conecta al servidor local que se ejecuta en el puerto 3000 en la máquina cliente.

Conexión exitosa(Socket.EVENT_CONNECT)imprimimos un mensaje indicando que estamos conectados al servidor.

Luego, emitimos un mensaje desde un cliente al servidor usando socket.Emit("message", "Hola desde el cliente C#"!"). Esto envía un mensaje con el contenido "Hola desde el cliente de C#"!al servidor.

A continuación, escuchamos los mensajes del servidor registrando un callback para el evento "message" usando socket.On("mensaje"(datos)=>{ ... }). Cuando el servidor envía un evento "message", se invoca la función de devolución de llamada y mostramos el mensaje recibido en la consola.

Si la conexión al servidor se desconecta del cliente(Socket.EVENT_DISCONNECT), imprimimos un mensaje indicando la desconexión.

Finalmente, el Console.ReadLine()El método mantiene la ventana de la consola abierta para que el programa no salga inmediatamente después de la ejecución. Esto nos permite ver la salida y asegura que el programa no termine prematuramente.

Captura de pantalla del código

HTTP long-polling

Long-polling es una técnica utilizada en el desarrollo web que emplea una biblioteca para enviar mensajes entre un cliente(normalmente un navegador web)y un servidor. Permite la comunicación en tiempo real al activar eventos en el servidor, que luego pueden ser recibidos por el cliente sin necesidad de sondeo continuo. Este método es particularmente útil para aplicaciones que requieren actualizaciones inmediatas, como aplicaciones de chat o cotizaciones de bolsa.

Sockets web

WebSocket facilita la comunicación bidireccional al establecer canales de comunicación dúplex completo sobre una sola conexión TCP. Este protocolo permite la interacción en tiempo real entre un cliente, típicamente un navegador web, y un servidor, facultando a ambas partes para intercambiar mensajes de forma asíncrona.

Estableciendo comunicación WebSocket

El cliente envía una solicitud de saludo WebSocket al servidor, indicando su deseo de establecer una conexión WebSocket. Al recibir la solicitud de handshake, el servidor responde con una respuesta de handshake de WebSocket, indicando que la conexión se ha establecido con éxito. Los mensajes enviados a través de la conexión WebSocket pueden estar en cualquier formato.(por ejemplo, texto o binario)y se pueden enviar y recibir de manera asincrónica.

Transporte Web

Web Transport, como un protocolo de vanguardia, introduce características adicionales para mejorar la comunicación web más allá de las limitaciones de los protocolos tradicionales como TCP y UDP. Al aprovechar UDP y QUIC, aborda las deficiencias de sus predecesores, haciéndolo más accesible y eficiente. Para los usuarios, esto se traduce en una latencia reducida y un mejor control de la congestión, lo que en última instancia ofrece una experiencia web más fluida y receptiva. Además, Web Transport ofrece mejores medidas de seguridad, garantizando una transmisión de datos más segura en comparación con TCP. Con estos avances, Web Transport mitiga los aspectos que consumen tiempo de la transferencia de datos, optimizando el rendimiento general tanto para clientes como para servidores.

Aquí tienes un ejemplo básico de cómo se puede utilizar Web Transport en una aplicación web:

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

Imports System
Imports System.Net.WebSockets
Imports System.Text
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 Namespace

En este ejemplo, primero creamos una nueva conexión WebTransport a un servidor utilizando una URL de WebSocket.(wss://echo.websocket.org). Luego, creamos un flujo bidireccional sobre la conexión y enviamos algunos datos.([1, 2, 3, 4])sobre el arroyo. Finalmente, leemos los datos del flujo y los registramos en la consola.

Salida del código anterior

Cuando ejecutes la aplicación con el servidor de eco WebSocket, la salida debería verse algo como esto:

Ventajas del Transporte Web

Alternativa Moderna: Web Transport ofrece una alternativa moderna a los protocolos de comunicación web tradicionales como TCP y UDP.

Transferencia de Datos Eficiente: Ofrece una transferencia de datos eficiente aprovechando flujos multiplexados y características avanzadas.

Alto Rendimiento: Ideal para desarrollar aplicaciones web de alto rendimiento que requieren baja latencia y transferencia de datos confiable.

Flujos Multiplexados: Admite flujos multiplexados, permitiendo que múltiples flujos de datos se envíen y reciban simultáneamente a través de una única conexión.

Innovación: A medida que los desarrolladores web continúan adoptando Web Transport, podemos esperar ver más innovación en los protocolos de comunicación web.

Experiencia de Usuario Mejorada: La adopción de Web Transport puede llevar a experiencias de usuario mejoradas en la web debido a una transferencia de datos más rápida y confiable.

Introducción a la biblioteca IronPDF

IronPDFes una biblioteca completa de PDF para .NET específicamente diseñada para desarrolladores que trabajan con C#. Esta poderosa herramienta permite a los desarrolladores sin esfuerzocrear, manipuleyleerArchivos PDF dentro de sus aplicaciones. Con IronPDF, los desarrolladores pueden generar documentos PDF desdeCadenas HTML, Archivos HTMLyURL, lo que lo hace altamente versátil para diversos casos de uso. Además, IronPDF ofrece funciones avanzadas de edición de PDF, como agregar encabezados, pies de página, marcas de agua y mucho más. Su integración perfecta en proyectos de C# a través del gestor de paquetes NuGet simplifica el proceso de trabajar con archivos PDF, optimizando el desarrollo y mejorando la productividad.

Instalación con el gestor de paquetes NuGet

Instala IronPDF en Visual Studio o desde la línea de comandos usando el Administrador de Paquetes NuGet. En Visual Studio, ve a la consola:

• Herramientas -> Gestor de paquetes NuGet -> Consola del Gestor de paquetes

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Ejemplo de código de IronPDF

Aquí tienes un ejemplo simple usando IronPDFpara convertir datos de bits en un archivo PDF, llame al método GeneratePDF en el método Main y pase los datos como parámetro que tuvimos en el ejemplo anterior

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

Imports System
Imports System.Net.WebSockets
Imports System.Text
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 Namespace

Código de clase de generación de PDF

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

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(data)
		  Dim filePath As String = "Data.pdf"
		  pdf.SaveAs(filePath)
		  Console.WriteLine($"PDF Generation Completed,File Saved as ${filePath}")
		End Sub
	End Class
End Namespace

Salida

En el código proporcionado, IronPDF se utiliza para generar un documento PDF a partir de una cadena hexadecimal recibida a través de una conexión WebSocket. El método GeneratePDF inicializa IronPDF con una clave de licencia y utiliza su instancia de ChromePdfRenderer para renderizar la cadena hexadecimal como contenido HTML en un PDF usando el método RenderHtmlAsPdf. Puede obtener su clave de licencia gratuita de aquí. Este PDF se guarda localmente como "Data.pdf" utilizando el método SaveAs. La integración de IronPDF permite la conversión fluida de datos dinámicos de WebSocket en un formato PDF estructurado, demostrando su utilidad para transformar flujos de datos en tiempo real en documentos archivables.

Archivo PDF generado

Conclusión

UtilizandoSocket.IOcon C# introduce numerosas oportunidades para interacciones en tiempo real con clientes conectados, extendiéndose más allá del ámbito de JavaScript y Node.js. Integrar herramientas comoSocket.IO yIronPDFen sus proyectos .NET puede mejorar significativamente las capacidades de comunicación en tiempo real y manejo de PDF. Socket.IO facilita la comunicación bidireccional en tiempo real y sin interrupciones entre clientes y servidores, mientras que IronPDF ofrece características robustas paracreación de ymanipulandoDocumentos PDF sin esfuerzo.

IronPDFpara desbloquear su máximo potencial, asegurando una generación y manipulación de PDF eficiente y confiable en sus aplicaciones C#.