La biblioteca PDF de C#
using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
Install-Package IronPdf
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.
EnSocket.IOse puede establecer conexión con diferentes transportes de bajo nivel:
Web Sockets
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.
Socket.IO, una biblioteca de JavaScript, permite a los clientes y servidores web comunicarse en tiempo real. Consiste en dos partes:
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 SocketIoClientDotNetInstall-Package 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.
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.
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();
}
}
}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.
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.
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.
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.
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));
}
}
}
}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.
Cuando ejecutes la aplicación con el servidor de eco WebSocket, la salida debería verse algo como esto:
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.
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.
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:
Install-Package IronPdfInstall-Package IronPdfAquí 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);
}
}
}
}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}");
}
}
}
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.
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#.
Install-Package IronPdf
No se necesita tarjeta de crédito
Su clave de prueba debería estar en el correo electrónico.
Si no es así, por favor contacte
support@ironsoftware.com
No se necesita tarjeta de crédito
Empezar GRATIS
No se necesita tarjeta de crédito
Pruebe en producción sin marcas de agua.
Funciona donde lo necesite.
Obtén 30 días de producto totalmente funcional.
Ténlo en funcionamiento en minutos.
Acceso completo a nuestro equipo de asistencia técnica durante la prueba del producto
No se necesita tarjeta de crédito ni crear una cuenta
Su clave de prueba debería estar en el correo electrónico.
Si no es así, por favor contacte con
support@ironsoftware.com
Empezar GRATIS
No se necesita tarjeta de crédito
Pruebe en producción sin marcas de agua.
Funciona donde lo necesite.
Obtén 30 días de producto totalmente funcional.
Ténlo en funcionamiento en minutos.
Acceso completo a nuestro equipo de asistencia técnica durante la prueba del producto
Licencias desde $749. ¿Tiene alguna pregunta? Póngase en contacto.
Reserve una demostración personal de 30 minutos.
Sin contrato, sin detalles de tarjeta, sin compromisos.
10 productos API de .NET para tus documentos de oficina
