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

El servidor Socket.IO 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

La conexión de Socket.IO se puede establecer con diferentes transporte a bajo nivel:

• HTTP long-polling

• Web Sockets

  • Transporte Web

  

Creando un proyecto de consola en Visual Studio 2022

Abra Visual Studio y seleccione 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 participar en comunicación 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 para aplicaciones .NET en Visual Studio, necesitarás una implementación de servidor compatible. Una de estas implementaciones es SocketIoClientDotNet para .NET, que permite a un cliente de Socket IO conectarse a un Socket.IO desde una aplicación de 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/emisor del cliente 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.

Al establecer una conexión exitosa (Socket.EVENT_CONNECT), imprimimos un mensaje indicando que estamos conectados al servidor.

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

A continuación, escuchamos mensajes del servidor registrando un callback para el evento "message" usando socket.On("message", (data) => { ... }). 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 método Console.ReadLine() mantiene la ventana de la consola abierta para que el programa no se cierre inmediatamente después de su 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 (generalmente 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 pueden ser enviados y recibidos 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). A continuación, creamos un flujo bidireccional sobre la conexión y enviamos algunos datos ([1, 2, 3, 4]) a través del flujo. 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 proporciona 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 al aprovechar flujos multiplexados y funciones avanzadas.

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

Flujos Multiplexados: Admite flujos multiplexados, lo que permite enviar y recibir múltiples flujos de datos 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.

Mejora de la experiencia del usuario: La adopción de Web Transport puede conducir a mejoras en la experiencia del usuario en la web debido a una transferencia de datos más rápida y confiable.

Introducción a la biblioteca IronPDF

IronPDF es una biblioteca PDF completa de .NET específicamente diseñada para desarrolladores que trabajan con C#. Esta poderosa herramienta permite a los desarrolladores crear, manipular y leer archivos PDF sin esfuerzo dentro de sus aplicaciones. Con IronPDF, los desarrolladores pueden generar documentos PDF a partir de cadenas HTML, archivos HTML y URLs, 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 sencillo usando IronPDF para convertir datos en un archivo PDF. Llama al método GeneratePDF en el método Main y pasa los datos como parámetro que teníamos 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 desde 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

Utilizar Socket.IO con 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 como Socket.IO y IronPDF en tus proyectos .NET puede mejorar significativamente las capacidades de comunicación en tiempo real y manejo de PDF. Socket.IO facilita una comunicación bidireccional en tiempo real sin interrupciones entre clientes y servidores, mientras que IronPDF ofrece funciones robustas para crear y manipular documentos PDF sin esfuerzo.

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