Socket io .NET (Cómo Funciona para Desarrolladores)

Socket.IO, una biblioteca de JavaScript, permite a los clientes web y servidores 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: Se ejecuta en Node.js.

Instalar los paquetes necesarios

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

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

Install-Package SocketIoClientDotNet

Captura de pantalla del paquete SocketIoClientDotNet

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

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

Creación de implementaciones de servidor

El siguiente código configura un servidor Socket.IO básico en C# que escucha las conexiones del cliente en el puerto 3000. Cuando un cliente envía un mensaje, el servidor registra el mensaje y 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();
        }
    }
}

Explicación del código

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

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

Luego, emitimos un mensaje desde el cliente al servidor usando 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 los mensajes del servidor registrando una devolución de llamada para el evento "message" usando socket.On("message", (data) => { ... }). Cuando el servidor envía un evento "message", se invoca la función de retorno, e imprimimos el mensaje recibido en la consola.

Si la conexión al servidor se desconecta desde el 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 salga inmediatamente tras la ejecución. Esto nos permite ver la salida y asegura que el programa no termine prematuramente.

Captura de pantalla del código

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

• Herramientas -> NuGet -> Consola del Administrador

Install-Package IronPdf

Ejemplo de código IronPDF

Aquí hay un ejemplo simple usando IronPDF para convertir datos binarios en un Archivo PDF. Llame al método GeneratePDF en el método Main y pase los datos como un parámetro que tuvimos en el ejemplo anterior:

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

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

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($"<h1>Received Data</h1><p>{data}</p>");
            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($"<h1>Received Data</h1><p>{data}</p>");
            string filePath = "Data.pdf";
            pdf.SaveAs(filePath);
            Console.WriteLine($"PDF Generation Completed. File Saved as {filePath}");
        }
    }
}