.NET AYUDA

Supersocket C# Ejemplo (Cómo Funciona para Desarrolladores)

Q: ¿Cómo puedo convertir HTML a PDF en una aplicación .NET?

Puedes usar el método RenderHtmlAsPdf de IronPDF para convertir cadenas HTML en PDFs y RenderHtmlFileAsPdf para convertir archivos HTML en PDFs dentro de una aplicación .NET.

Jacob Mellor

Actualizado:julio 28, 2025

Desarrollo de una aplicación de socket del lado del servidor con SuperSocket e integración de IronPDF

SuperSocket C# es un excelente marco para desarrollar una aplicación de socket del lado del servidor, ya sea que estés trabajando en un servidor GPS o en un sistema de control industrial. Admite varias implementaciones de protocolos de red y asegura que tu socket funcione eficientemente. Este ligero marco multiplataforma está diseñado para ser extensible, proporcionando flexibilidad para diferentes entornos. Con SuperSocket, puedes enviar fácilmente datos entre clientes y servidores, y su código fuente está disponible para personalización según los requisitos específicos del proyecto.

Es un marco de código abierto, por lo que cualquier desarrollador puede implementarlo y acceder a él a través de GitHub.

Ejemplo de SuperSocket C# (Cómo funciona para desarrolladores): Figura 1 - Página de GitHub para SuperSocket

IronPDF es una potente biblioteca .NET para crear, editar y extraer contenido de documentos PDF. Está diseñado para desarrolladores que necesitan integrar funcionalidad PDF en sus aplicaciones. IronPDF admite varias características como generar PDFs desde HTML, fusionar PDFs, y extraer texto e imágenes de PDFs.

SuperSocket e IronPDF juntos pueden potenciar aplicaciones complejas del lado del servidor. Ofrecen una amplia gama de funcionalidades para satisfacer las necesidades de los desarrolladores modernos de .NET. Estas bibliotecas son perfectas, ya sea que estés creando un servidor de adquisición de datos o un robusto servidor de juegos donde las aplicaciones de chat en tiempo real son necesarias.

Cómo empezar con SuperSocket C#

Cómo configurar SuperSocket C# en proyectos .NET

Para comenzar a usar SuperSocket C#, debes configurar tu proyecto .NET. Primero, instala el paquete SuperSocket NuGet. Abre tu proyecto en Visual Studio y ejecuta el siguiente comando en la Consola del Administrador de Paquetes:

Install-Package SuperSocket

Ejemplo de SuperSocket C# (Cómo funciona para desarrolladores): Figura 2 - Salida de la consola tras instalar SuperSocket

Una vez instalado, puedes configurar tu instancia de servidor. Crea un nuevo archivo de configuración llamado appsettings.json. Este archivo definirá la configuración del servidor, incluidos los oyentes y protocolos.

{
  "serverOptions": {
    "name": "SuperSocketServer",
    "listeners": [
      {
        "ip": "Any",
        "port": 4040
      }
    ]
  }
}

Luego, crea una clase para configurar el servidor. Esta clase leerá la configuración de appsettings.json e inicializará la instancia del servidor.

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class ServerConfig
{
    public async Task Configure()
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<YourSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class ServerConfig
{
    public async Task Configure()
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<YourSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

Imports Microsoft.Extensions.Configuration
Imports SuperSocket
Imports SuperSocket.Server

Public Class ServerConfig
	Public Async Function Configure() As Task
		Dim host = SuperSocketHostBuilder.Create().UseTcpServer().UseSession(Of YourSession)().ConfigureAppConfiguration(Sub(hostCtx, configApp)
				configApp.AddJsonFile("appsettings.json", [optional]:= False, reloadOnChange:= True)
		End Sub).Build()
		Await host.RunAsync()
	End Function
End Class

$vbLabelText $csharpLabel

Un ejemplo básico de SuperSocket C

Veamos un ejemplo básico de una aplicación SuperSocket C#. Este ejemplo demuestra cómo crear un servidor de eco simple que envía de vuelta cualquier dato recibido.

Primero, define la clase de sesión. Esta clase manejará las conexiones de socket y administrará la comunicación de datos.

using SuperSocket;

public class EchoSession : AppSession
{
    protected override async ValueTask OnSessionStartedAsync()
    {
        await base.OnSessionStartedAsync();
        Console.WriteLine("New session started.");
    }

    protected override async ValueTask OnSessionClosedAsync(CloseEventArgs e)
    {
        await base.OnSessionClosedAsync(e);
        Console.WriteLine("Session closed.");
    }

    protected override async ValueTask OnPackageReceivedAsync(ReadOnlyMemory<byte> package)
    {
        await SendAsync(package);
    }
}

using SuperSocket;

public class EchoSession : AppSession
{
    protected override async ValueTask OnSessionStartedAsync()
    {
        await base.OnSessionStartedAsync();
        Console.WriteLine("New session started.");
    }

    protected override async ValueTask OnSessionClosedAsync(CloseEventArgs e)
    {
        await base.OnSessionClosedAsync(e);
        Console.WriteLine("Session closed.");
    }

    protected override async ValueTask OnPackageReceivedAsync(ReadOnlyMemory<byte> package)
    {
        await SendAsync(package);
    }
}

Imports SuperSocket

Public Class EchoSession
	Inherits AppSession

	Protected Overrides Async Function OnSessionStartedAsync() As ValueTask
		Await MyBase.OnSessionStartedAsync()
		Console.WriteLine("New session started.")
	End Function

	Protected Overrides Async Function OnSessionClosedAsync(ByVal e As CloseEventArgs) As ValueTask
		Await MyBase.OnSessionClosedAsync(e)
		Console.WriteLine("Session closed.")
	End Function

	Protected Overrides Async Function OnPackageReceivedAsync(ByVal package As ReadOnlyMemory(Of Byte)) As ValueTask
		Await SendAsync(package)
	End Function
End Class

$vbLabelText $csharpLabel

Luego, configura y ejecuta el servidor con la sesión de eco.

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class EchoServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<EchoSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class EchoServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<EchoSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

Imports Microsoft.Extensions.Configuration
Imports SuperSocket
Imports SuperSocket.Server

Public Class EchoServer
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim host = SuperSocketHostBuilder.Create().UseTcpServer().UseSession(Of EchoSession)().ConfigureAppConfiguration(Sub(hostCtx, configApp)
				configApp.AddJsonFile("appsettings.json", [optional]:= False, reloadOnChange:= True)
		End Sub).Build()
		Await host.RunAsync()
	End Function
End Class

$vbLabelText $csharpLabel

Este ejemplo muestra cómo crear un servidor de eco simple usando SuperSocket C#. El servidor escucha las conexiones y devuelve cualquier dato que recibe.

Implementación de las características de SuperSocket C#

Manejo de múltiples receptores

SuperSocket C# admite múltiples oyentes, lo que permite a tu servidor manejar diferentes protocolos y puertos. Esta función es útil para crear aplicaciones versátiles como servidores de adquisición de datos y servidores GPS.

Primero, actualiza tu appsettings.json para incluir múltiples oyentes:

{
  "serverOptions": {
    "name": "MultiListenerServer",
    "listeners": [
      {
        "ip": "Any",
        "port": 4040
      },
      {
        "ip": "Any",
        "port": 5050
      }
    ]
  }
}

A continuación, configura el servidor para usar estos oyentes:

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class MultiListenerServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<YourSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class MultiListenerServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<YourSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

Imports Microsoft.Extensions.Configuration
Imports SuperSocket
Imports SuperSocket.Server

Public Class MultiListenerServer
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim host = SuperSocketHostBuilder.Create().UseTcpServer().UseSession(Of YourSession)().ConfigureAppConfiguration(Sub(hostCtx, configApp)
				configApp.AddJsonFile("appsettings.json", [optional]:= False, reloadOnChange:= True)
		End Sub).Build()
		Await host.RunAsync()
	End Function
End Class

$vbLabelText $csharpLabel

Con esta configuración, tu servidor puede manejar conexiones en ambos puertos 4040 y 5050. Esta capacidad es crucial para aplicaciones que necesitan gestionar varios protocolos de red.

Implementación del manejo de datos binarios

SuperSocket C# es eficiente en el manejo de datos binarios. Esto es importante para aplicaciones que requieren compatibilidad a nivel binario, como sistemas de control industrial.

Primero, define una clase de sesión que procese datos binarios:

using System;
using SuperSocket;

public class BinaryDataSession : AppSession
{
    protected override async ValueTask OnPackageReceivedAsync(ReadOnlyMemory<byte> package)
    {
        var data = package.ToArray();
        Console.WriteLine("Received binary data: " + BitConverter.ToString(data));
        await SendAsync(data);
    }
}

using System;
using SuperSocket;

public class BinaryDataSession : AppSession
{
    protected override async ValueTask OnPackageReceivedAsync(ReadOnlyMemory<byte> package)
    {
        var data = package.ToArray();
        Console.WriteLine("Received binary data: " + BitConverter.ToString(data));
        await SendAsync(data);
    }
}

Imports System
Imports SuperSocket

Public Class BinaryDataSession
	Inherits AppSession

	Protected Overrides Async Function OnPackageReceivedAsync(ByVal package As ReadOnlyMemory(Of Byte)) As ValueTask
		Dim data = package.ToArray()
		Console.WriteLine("Received binary data: " & BitConverter.ToString(data))
		Await SendAsync(data)
	End Function
End Class

$vbLabelText $csharpLabel

A continuación, configura y ejecuta el servidor con la sesión de datos binarios:

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class BinaryDataServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<BinaryDataSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class BinaryDataServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<BinaryDataSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

Imports Microsoft.Extensions.Configuration
Imports SuperSocket
Imports SuperSocket.Server

Public Class BinaryDataServer
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim host = SuperSocketHostBuilder.Create().UseTcpServer().UseSession(Of BinaryDataSession)().ConfigureAppConfiguration(Sub(hostCtx, configApp)
				configApp.AddJsonFile("appsettings.json", [optional]:= False, reloadOnChange:= True)
		End Sub).Build()
		Await host.RunAsync()
	End Function
End Class

$vbLabelText $csharpLabel

Este ejemplo demuestra cómo recibir y enviar datos binarios usando SuperSocket C#. Es útil para aplicaciones de alto rendimiento que necesitan procesar protocolos binarios.

Gestión de conexiones de socket

Mantener conexiones de socket es esencial para asegurar una comunicación confiable. SuperSocket C# simplifica este proceso.

Primero, define una clase de sesión que gestione las conexiones de socket:

using SuperSocket;

public class ConnectionSession : AppSession
{
    protected override async ValueTask OnSessionStartedAsync()
    {
        await base.OnSessionStartedAsync();
        Console.WriteLine("Connection started.");
    }

    protected override async ValueTask OnSessionClosedAsync(CloseEventArgs e)
    {
        await base.OnSessionClosedAsync(e);
        Console.WriteLine("Connection closed.");
    }

    protected override async ValueTask OnPackageReceivedAsync(ReadOnlyMemory<byte> package)
    {
        await SendAsync(package);
    }
}

using SuperSocket;

public class ConnectionSession : AppSession
{
    protected override async ValueTask OnSessionStartedAsync()
    {
        await base.OnSessionStartedAsync();
        Console.WriteLine("Connection started.");
    }

    protected override async ValueTask OnSessionClosedAsync(CloseEventArgs e)
    {
        await base.OnSessionClosedAsync(e);
        Console.WriteLine("Connection closed.");
    }

    protected override async ValueTask OnPackageReceivedAsync(ReadOnlyMemory<byte> package)
    {
        await SendAsync(package);
    }
}

Imports SuperSocket

Public Class ConnectionSession
	Inherits AppSession

	Protected Overrides Async Function OnSessionStartedAsync() As ValueTask
		Await MyBase.OnSessionStartedAsync()
		Console.WriteLine("Connection started.")
	End Function

	Protected Overrides Async Function OnSessionClosedAsync(ByVal e As CloseEventArgs) As ValueTask
		Await MyBase.OnSessionClosedAsync(e)
		Console.WriteLine("Connection closed.")
	End Function

	Protected Overrides Async Function OnPackageReceivedAsync(ByVal package As ReadOnlyMemory(Of Byte)) As ValueTask
		Await SendAsync(package)
	End Function
End Class

$vbLabelText $csharpLabel

A continuación, configura y ejecuta el servidor con la sesión de conexión:

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class ConnectionServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<ConnectionSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Server;

public class ConnectionServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<ConnectionSession>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

Imports Microsoft.Extensions.Configuration
Imports SuperSocket
Imports SuperSocket.Server

Public Class ConnectionServer
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim host = SuperSocketHostBuilder.Create().UseTcpServer().UseSession(Of ConnectionSession)().ConfigureAppConfiguration(Sub(hostCtx, configApp)
				configApp.AddJsonFile("appsettings.json", [optional]:= False, reloadOnChange:= True)
		End Sub).Build()
		Await host.RunAsync()
	End Function
End Class

$vbLabelText $csharpLabel

Esta configuración ayuda a gestionar las conexiones de socket, asegurando que tu servidor permanezca robusto y confiable.

Creación de un servidor de línea de comandos

SuperSocket C# admite la creación de servidores de línea de comandos. Esta función es útil para aplicaciones que requieren protocolos simples basados en texto.

Primero, define una clase de comando que procese comandos de texto:

using System.Text;
using System.Threading.Tasks;
using SuperSocket.Command;
using SuperSocket.ProtoBase;

public class MyCommand : IAsyncCommand<AppSession, StringPackageInfo>
{
    public async ValueTask ExecuteAsync(AppSession session, StringPackageInfo package)
    {
        var commandKey = package.Key;
        var parameters = package.Parameters;
        await session.SendAsync(Encoding.UTF8.GetBytes($"You said: {string.Join(' ', parameters)}"));
    }
}

using System.Text;
using System.Threading.Tasks;
using SuperSocket.Command;
using SuperSocket.ProtoBase;

public class MyCommand : IAsyncCommand<AppSession, StringPackageInfo>
{
    public async ValueTask ExecuteAsync(AppSession session, StringPackageInfo package)
    {
        var commandKey = package.Key;
        var parameters = package.Parameters;
        await session.SendAsync(Encoding.UTF8.GetBytes($"You said: {string.Join(' ', parameters)}"));
    }
}

Imports System.Text
Imports System.Threading.Tasks
Imports SuperSocket.Command
Imports SuperSocket.ProtoBase

Public Class MyCommand
	Implements IAsyncCommand(Of AppSession, StringPackageInfo)

	Public Async Function ExecuteAsync(ByVal session As AppSession, ByVal package As StringPackageInfo) As ValueTask
		Dim commandKey = package.Key
		Dim parameters = package.Parameters
		Await session.SendAsync(Encoding.UTF8.GetBytes($"You said: {String.Join(" "c, parameters)}"))
	End Function
End Class

$vbLabelText $csharpLabel

A continuación, configura el servidor para usar el comando:

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Command;
using SuperSocket.ProtoBase;
using SuperSocket.Server;

public class CommandLineServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<AppSession>()
            .UseCommand<StringPackageParser>()
            .AddCommand<MyCommand>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

using Microsoft.Extensions.Configuration;
using SuperSocket;
using SuperSocket.Command;
using SuperSocket.ProtoBase;
using SuperSocket.Server;

public class CommandLineServer
{
    public static async Task Main(string[] args)
    {
        var host = SuperSocketHostBuilder.Create()
            .UseTcpServer()
            .UseSession<AppSession>()
            .UseCommand<StringPackageParser>()
            .AddCommand<MyCommand>()
            .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .Build();
        await host.RunAsync();
    }
}

Imports Microsoft.Extensions.Configuration
Imports SuperSocket
Imports SuperSocket.Command
Imports SuperSocket.ProtoBase
Imports SuperSocket.Server

Public Class CommandLineServer
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim host = SuperSocketHostBuilder.Create().UseTcpServer().UseSession(Of AppSession)().UseCommand(Of StringPackageParser)().AddCommand(Of MyCommand)().ConfigureAppConfiguration(Sub(hostCtx, configApp)
				configApp.AddJsonFile("appsettings.json", [optional]:= False, reloadOnChange:= True)
		End Sub).Build()
		Await host.RunAsync()
	End Function
End Class

$vbLabelText $csharpLabel

Este ejemplo muestra cómo crear un servidor de línea de comandos simple usando SuperSocket C#. Es ideal para protocolos ligeros basados en texto.

Integración de SuperSocket C# con IronPDF

Integrar IronPDF con SuperSocket en tus aplicaciones C# puede mejorar significativamente las capacidades de tu servidor, especialmente cuando se trata de manejar archivos PDF. Exploremos cómo fusionar efectivamente estas dos poderosas bibliotecas.

Introducción a IronPDF

Página web de IronPDF

IronPDF for .NET Library es una versátil biblioteca .NET diseñada para crear, editar y extraer contenido de documentos PDF. Ya sea que necesites generar informes, facturas u otros documentos basados en PDF, IronPDF proporciona una API fácil de usar para realizar estas tareas. Su característica principal son sus capacidades de Conversión de HTML a PDF. Es una gran herramienta para desarrolladores que buscan incorporar funcionalidad PDF en sus aplicaciones sin lidiar con las complejidades de las especificaciones PDF.

IronPDF se destaca en la conversión de HTML a PDF, asegurando la preservación precisa de los diseños y estilos originales. Es perfecto para crear PDFs a partir de contenido basado en la web como informes, facturas y documentación. Con soporte para archivos HTML, URLs y cadenas HTML en bruto, IronPDF produce fácilmente documentos PDF de alta calidad.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

$vbLabelText $csharpLabel

Caso de uso de la fusión de IronPDF con SuperSocket C#

Imagina que tienes un servidor construido con SuperSocket que necesita manejar solicitudes de clientes para generar y enviar documentos PDF de manera dinámica. Al integrar IronPDF, tu servidor puede procesar estas solicitudes, crear PDFs al instante y enviarlos de vuelta a los clientes de forma fluida.

Ejemplo de código del caso de uso

Aquí tienes un ejemplo de código completo que demuestra cómo integrar IronPDF con SuperSocket. Este ejemplo configura un servidor SuperSocket simple que escucha conexiones de clientes, procesa una solicitud para generar un PDF, y envía el PDF generado de regreso al cliente.

using System;
using System.Net;
using System.Text;
using IronPdf;
using SuperSocket.SocketBase;
using SuperSocket.SocketBase.Protocol;

namespace SuperSocketIronPDFExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var appServer = new AppServer();
            var serverConfig = new SuperSocket.SocketBase.Config.ServerConfig
            {
                Name = "SuperSocketServer",
                Ip = "Any",
                Port = 2012,
                Mode = SuperSocket.SocketBase.SocketMode.Tcp,
                MaxConnectionNumber = 100,
            };

            if (!appServer.Setup(serverConfig))
            {
                Console.WriteLine("Failed to set up!");
                return;
            }

            appServer.NewSessionConnected += NewSessionConnected;
            appServer.NewRequestReceived += (session, requestInfo) =>
            {
                if (requestInfo.Key == "GENPDF")
                {
                    var pdfDocument = CreatePdfDocument(requestInfo.Body);
                    var pdfBytes = pdfDocument.BinaryData;
                    session.Send(pdfBytes, 0, pdfBytes.Length);
                    Console.WriteLine("PDF document sent to client.");
                }
            };

            if (!appServer.Start())
            {
                Console.WriteLine("Failed to start!");
                return;
            }

            Console.WriteLine("Server is running. Press any key to stop...");
            Console.ReadKey();
            appServer.Stop();
        }

        private static PdfDocument CreatePdfDocument(string content)
        {
            var pdfRenderer = new ChromePdfRenderer();
            var pdfDocument = pdfRenderer.RenderHtmlAsPdf(content);
            return pdfDocument;
        }

        private static void NewSessionConnected(AppSession session)
        {
            Console.WriteLine($"New session connected: {session.SessionID}");
        }
    }

    public class AppServer : AppServer<AppSession, StringRequestInfo>
    {
    }

    public class AppSession : AppSession<AppSession, StringRequestInfo>
    {
    }
}

using System;
using System.Net;
using System.Text;
using IronPdf;
using SuperSocket.SocketBase;
using SuperSocket.SocketBase.Protocol;

namespace SuperSocketIronPDFExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var appServer = new AppServer();
            var serverConfig = new SuperSocket.SocketBase.Config.ServerConfig
            {
                Name = "SuperSocketServer",
                Ip = "Any",
                Port = 2012,
                Mode = SuperSocket.SocketBase.SocketMode.Tcp,
                MaxConnectionNumber = 100,
            };

            if (!appServer.Setup(serverConfig))
            {
                Console.WriteLine("Failed to set up!");
                return;
            }

            appServer.NewSessionConnected += NewSessionConnected;
            appServer.NewRequestReceived += (session, requestInfo) =>
            {
                if (requestInfo.Key == "GENPDF")
                {
                    var pdfDocument = CreatePdfDocument(requestInfo.Body);
                    var pdfBytes = pdfDocument.BinaryData;
                    session.Send(pdfBytes, 0, pdfBytes.Length);
                    Console.WriteLine("PDF document sent to client.");
                }
            };

            if (!appServer.Start())
            {
                Console.WriteLine("Failed to start!");
                return;
            }

            Console.WriteLine("Server is running. Press any key to stop...");
            Console.ReadKey();
            appServer.Stop();
        }

        private static PdfDocument CreatePdfDocument(string content)
        {
            var pdfRenderer = new ChromePdfRenderer();
            var pdfDocument = pdfRenderer.RenderHtmlAsPdf(content);
            return pdfDocument;
        }

        private static void NewSessionConnected(AppSession session)
        {
            Console.WriteLine($"New session connected: {session.SessionID}");
        }
    }

    public class AppServer : AppServer<AppSession, StringRequestInfo>
    {
    }

    public class AppSession : AppSession<AppSession, StringRequestInfo>
    {
    }
}

Imports System
Imports System.Net
Imports System.Text
Imports IronPdf
Imports SuperSocket.SocketBase
Imports SuperSocket.SocketBase.Protocol

Namespace SuperSocketIronPDFExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			Dim appServer As New AppServer()
			Dim serverConfig = New SuperSocket.SocketBase.Config.ServerConfig With {
				.Name = "SuperSocketServer",
				.Ip = "Any",
				.Port = 2012,
				.Mode = SuperSocket.SocketBase.SocketMode.Tcp,
				.MaxConnectionNumber = 100
			}

			If Not appServer.Setup(serverConfig) Then
				Console.WriteLine("Failed to set up!")
				Return
			End If

			AddHandler appServer.NewSessionConnected, AddressOf NewSessionConnected
			AddHandler appServer.NewRequestReceived, Sub(session, requestInfo)
				If requestInfo.Key = "GENPDF" Then
					Dim pdfDocument = CreatePdfDocument(requestInfo.Body)
					Dim pdfBytes = pdfDocument.BinaryData
					session.Send(pdfBytes, 0, pdfBytes.Length)
					Console.WriteLine("PDF document sent to client.")
				End If
			End Sub

			If Not appServer.Start() Then
				Console.WriteLine("Failed to start!")
				Return
			End If

			Console.WriteLine("Server is running. Press any key to stop...")
			Console.ReadKey()
			appServer.Stop()
		End Sub

		Private Shared Function CreatePdfDocument(ByVal content As String) As PdfDocument
			Dim pdfRenderer = New ChromePdfRenderer()
			Dim pdfDocument = pdfRenderer.RenderHtmlAsPdf(content)
			Return pdfDocument
		End Function

		Private Shared Sub NewSessionConnected(ByVal session As AppSession)
			Console.WriteLine($"New session connected: {session.SessionID}")
		End Sub
	End Class

	Public Class AppServer
		Inherits AppServer(Of AppSession, StringRequestInfo)

	End Class

	Public Class AppSession
		Inherits AppSession(Of AppSession, StringRequestInfo)

	End Class
End Namespace

$vbLabelText $csharpLabel

Esta integración te permite aprovechar las poderosas características de IronPDF dentro de un servidor SuperSocket, habilitando la generación dinámica de PDF y una comunicación cliente-servidor eficiente.

Conclusión

Información de licencia de IronPDF

Integrar SuperSocket con las Características Completas de IronPDF es una combinación poderosa para crear aplicaciones de servidor dinámicas y de alto rendimiento que pueden manejar la generación y el procesamiento de PDF de manera fluida. Con el robusto marco de servidor de socket de SuperSocket y las amplias funcionalidades de PDF de IronPDF, puedes desarrollar aplicaciones escalables y versátiles para satisfacer diversas necesidades, desde sistemas de adquisición de datos hasta servidores de juegos y sistemas de control industrial.

IronPDF ofrece una prueba gratis, y su licencia comienza desde $799, proporcionando un excelente valor para las capacidades extensas que aporta a tus proyectos de desarrollo. Al fusionar estas dos bibliotecas, puedes simplificar la capacidad de tu servidor para manejar tareas complejas de manera eficiente, mejorando tanto la funcionalidad como el rendimiento.

Preguntas Frecuentes

¿Para qué se utiliza SuperSocket C#?

SuperSocket C# se utiliza para desarrollar aplicaciones de sockets del lado del servidor. Es altamente extensible y admite varios protocolos de red, haciéndolo adecuado para entornos como servidores GPS y sistemas de control industrial.

¿Cómo puedo convertir HTML a PDF en una aplicación .NET?

Puedes usar el método RenderHtmlAsPdf de IronPDF para convertir cadenas HTML en PDFs y RenderHtmlFileAsPdf para convertir archivos HTML en PDFs dentro de una aplicación .NET.

¿Cómo configuras un servidor SuperSocket en un proyecto .NET?

Para configurar un servidor SuperSocket en un proyecto .NET, necesitas instalar el paquete NuGet de SuperSocket, configurar el servidor usando un archivo appsettings.json e inicializar el servidor dentro de tu código de aplicación.

¿Cómo puede IronPDF mejorar las aplicaciones del lado del servidor?

IronPDF puede mejorar las aplicaciones del lado del servidor proporcionando capacidades de generación y procesamiento dinámico de PDF, permitiendo la creación y distribución en tiempo real de documentos PDF basados en las solicitudes del cliente.

¿Puede SuperSocket manejar múltiples escuchas de protocolo?

Sí, SuperSocket puede manejar múltiples escuchas de protocolo, permitiendo que una sola instancia de servidor maneje varios protocolos y puertos simultáneamente para aplicaciones como servidores de adquisición de datos.

¿Qué beneficios ofrece IronPDF para el manejo de documentos PDF?

IronPDF ofrece características integrales para crear, editar y extraer contenido de documentos PDF. Es ideal para aplicaciones que requieren un manejo y manipulación avanzada de documentos PDF.

¿Cómo maneja SuperSocket las conexiones de socket concurrentes?

SuperSocket maneja las conexiones de socket concurrentes usando clases de sesión para gestionar eventos de conexión, asegurando una comunicación fiable y un rendimiento robusto del servidor incluso bajo alta carga.

¿Es posible integrar funcionalidades de PDF en aplicaciones de SuperSocket?

Sí, al integrar IronPDF en tus aplicaciones de SuperSocket, puedes añadir funcionalidades de PDF, como la generación y edición dinámica de PDF, mejorando las capacidades de la aplicación.

¿Cuáles son los casos de uso comunes para SuperSocket?

Los casos de uso comunes para SuperSocket incluyen servidores GPS, sistemas de control industrial, servidores de adquisición de datos y servidores de juegos en tiempo real, los cuales se benefician de una comunicación de socket eficiente y fiable.

¿Cómo puedo manejar datos binarios en SuperSocket?

SuperSocket maneja datos binarios de manera eficiente utilizando clases de sesión para procesar paquetes binarios entrantes y enviar respuestas, lo cual es esencial para aplicaciones que requieren procesamiento de datos a nivel binario.

¿IronPDF admite la conversión de HTML a PDF en aplicaciones del servidor?

Sí, IronPDF admite la conversión de HTML a PDF en aplicaciones del servidor, permitiendo la transformación del contenido HTML en documentos PDF de alta calidad de manera fluida.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

Jacob Mellor es Director de Tecnología en Iron Software y un ingeniero visionario que lidera la tecnología PDF en C#. Como el desarrollador original detrás de la base de código central de Iron Software, ha moldeado la arquitectura de productos de la compañía desde ...

Quartz .NET (Cómo Funciona para Desarrolladores)

Dottrace .NET Core (Cómo Funciona ...

Destacado del Cliente:

Enfoque del Desarrollador:

Webinars:

Supersocket C# Ejemplo (Cómo Funciona para Desarrolladores)

Desarrollo de una aplicación de socket del lado del servidor con SuperSocket e integración de IronPDF

Cómo empezar con SuperSocket C#

Cómo configurar SuperSocket C# en proyectos .NET

Un ejemplo básico de SuperSocket C

Implementación de las características de SuperSocket C#

Manejo de múltiples receptores

Implementación del manejo de datos binarios

Gestión de conexiones de socket

Creación de un servidor de línea de comandos

Integración de SuperSocket C# con IronPDF

Introducción a IronPDF

Caso de uso de la fusión de IronPDF con SuperSocket C#

Ejemplo de código del caso de uso

Conclusión

Preguntas Frecuentes

¿Para qué se utiliza SuperSocket C#?

¿Cómo puedo convertir HTML a PDF en una aplicación .NET?

¿Cómo configuras un servidor SuperSocket en un proyecto .NET?

¿Cómo puede IronPDF mejorar las aplicaciones del lado del servidor?

¿Puede SuperSocket manejar múltiples escuchas de protocolo?

¿Qué beneficios ofrece IronPDF para el manejo de documentos PDF?

¿Cómo maneja SuperSocket las conexiones de socket concurrentes?

¿Es posible integrar funcionalidades de PDF en aplicaciones de SuperSocket?

¿Cuáles son los casos de uso comunes para SuperSocket?

¿Cómo puedo manejar datos binarios en SuperSocket?

¿IronPDF admite la conversión de HTML a PDF en aplicaciones del servidor?

Supersocket C# Ejemplo (Cómo Funciona para Desarrolladores)

Desarrollo de una aplicación de socket del lado del servidor con SuperSocket e integración de IronPDF

Cómo empezar con SuperSocket C#

Cómo configurar SuperSocket C# en proyectos .NET

Un ejemplo básico de SuperSocket C

Implementación de las características de SuperSocket C#

Manejo de múltiples receptores

Implementación del manejo de datos binarios

Gestión de conexiones de socket

Creación de un servidor de línea de comandos

Integración de SuperSocket C# con IronPDF

Introducción a IronPDF

Caso de uso de la fusión de IronPDF con SuperSocket C#

Ejemplo de código del caso de uso

Conclusión

Preguntas Frecuentes

¿Para qué se utiliza SuperSocket C#?

¿Cómo puedo convertir HTML a PDF en una aplicación .NET?

¿Cómo configuras un servidor SuperSocket en un proyecto .NET?

¿Cómo puede IronPDF mejorar las aplicaciones del lado del servidor?

¿Puede SuperSocket manejar múltiples escuchas de protocolo?

¿Qué beneficios ofrece IronPDF para el manejo de documentos PDF?

¿Cómo maneja SuperSocket las conexiones de socket concurrentes?

¿Es posible integrar funcionalidades de PDF en aplicaciones de SuperSocket?

¿Cuáles son los casos de uso comunes para SuperSocket?

¿Cómo puedo manejar datos binarios en SuperSocket?

¿IronPDF admite la conversión de HTML a PDF en aplicaciones del servidor?

Artículos Relacionados

Bridging CLI Simplicity & .NET : Uso de Curl DotNet con IronPDF

RandomNumberGenerator C#

C# String Equals (Cómo Funciona para Desarrolladores)

Próximo paso: Comenzar prueba gratuita de 30 días

Próximo paso: Comenzar prueba gratuita de 30 días

Confiado por más de 2 millones de ingenieros en todo el mundo