1. IronPDF
  2. Blog de IronPDF
  3. Ayuda .NET
  4. Supersocket C#
AYUDA .NET

Ejemplo de Supersocket en C# (Cómo funciona para desarrolladores)

Regan Pun
Regan Pun
1 de julio, 2024
Compartir:

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

SuperSocket C#** es un marco excelente para desarrollar una aplicación socket del lado del servidor, tanto si trabajas en un servidor GPS como en un sistema de control industrial. Es compatible con varias implementaciones de protocolos de red y garantiza que su socket funcione con eficacia. Este marco de trabajo ligero y multiplataforma está diseñado para ser extensible, proporcionando flexibilidad para diferentes entornos. Con SuperSocket, puede enviar datos fácilmente entre clientes y servidores, y su código fuente está disponible para su personalización con el fin de satisfacer los requisitos específicos de cada proyecto.

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

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

IronPDF es una potente biblioteca .NET para crear, editar y extraer contenido de documentos PDF. Está diseñado para desarrolladores que necesitan integrar funciones PDF en sus aplicaciones. IronPDF admite varias funciones, como la generación de PDF a partir de HTML, la fusión de PDF y la extracción de texto e imágenes de PDF.

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 .NET modernos. Estas librerías son perfectas tanto para construir un servidor de adquisición de datos como un robusto servidor de juegos en el que sean necesarias aplicaciones de chat en tiempo real.

Primeros pasos con SuperSocket C

Configuración de SuperSocket C# en proyectos .NET

Para empezar a utilizar SuperSocket C#, debe configurar su proyecto .NET. En primer lugar, instale el paquete NuGet de SuperSocket. Abra su proyecto en Visual Studio y ejecute el siguiente comando en la consola del gestor de paquetes:

Install-Package SuperSocket

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

Una vez instalado, puede configurar su 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 los protocolos.

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

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

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

Un ejemplo básico de SuperSocket en C

Veamos un ejemplo básico de una aplicación SuperSocket C#. Este ejemplo muestra cómo crear un servidor echo simple que devuelve cualquier dato recibido.

En primer lugar, defina la clase de sesión. Esta clase manejará las conexiones de socket y gestionará la comunicación de datos.

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

A continuación, configure y ejecute el servidor con la sesión de eco.

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

Este ejemplo muestra cómo crear un servidor echo simple usando SuperSocket C#. El servidor escucha las conexiones y se hace eco de los datos que recibe.

Implementación de funciones de SuperSocket en C

Manejo de múltiples oyentes

SuperSocket C# soporta múltiples escuchas, permitiendo a su 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.

En primer lugar, actualiza tu appsettings.json para incluir múltiples escuchas:

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

A continuación, configure el servidor para que utilice estas escuchas:

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

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

Tratamiento 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 los sistemas de control industrial.

En primer lugar, defina una clase de sesión que procese datos binarios:

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

A continuación, configure y ejecute el servidor con la sesión de datos binarios:

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

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

Gestión de conexiones de socket

Mantener las conexiones de los enchufes es esencial para garantizar una comunicación fiable. SuperSocket C# simplifica este proceso.

En primer lugar, defina una clase de sesión que gestione las conexiones de socket:

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

A continuación, configure y ejecute el servidor con la sesión de conexión:

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

Esta configuración ayuda a gestionar las conexiones de socket, garantizando que su servidor siga siendo robusto y fiable.

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

SuperSocket C# permite crear servidores de línea de comandos. Esta función es útil para aplicaciones que requieren protocolos sencillos basados en texto.

En primer lugar, defina una clase de comandos que procese comandos de texto:

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

A continuación, configure el servidor para que utilice el comando:

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

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

Integración de SuperSocket C# con IronPDF

La integración de IronPDF con SuperSocket en sus aplicaciones C# puede mejorar significativamente las capacidades de su servidor, especialmente cuando se trata de manejar archivos PDF. Exploremos cómo combinar eficazmente estas dos potentes bibliotecas.

Introducción a IronPDF

Página web de IronPDF

*biblioteca .NET de IronPDF*** es una versátil biblioteca .NET diseñada para crear, editar y extraer contenido de documentos PDF. Si necesita generar informes, facturas o cualquier otro documento basado en PDF, IronPDF proporciona una API fácil de usar para realizar estas tareas. Su principal característica es su**Conversión de HTML a PDF capacidades. Es una gran herramienta para los desarrolladores que deseen incorporar funciones PDF a sus aplicaciones sin tener que lidiar con las complejidades de las especificaciones PDF.

IronPDF destaca enHTML a PDFconversión, 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 de 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");
    }
}

Caso práctico de fusión de IronPDF con SuperSocket C

Imagine que tiene un servidor construido con SuperSocket que necesita gestionar peticiones de clientes para generar y enviar documentos PDF de forma dinámica. Al integrar IronPDF, su servidor puede procesar estas solicitudes, crear PDF sobre la marcha y enviarlos de vuelta a los clientes sin problemas.

Ejemplo de código del caso de uso

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

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
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 ServerConfig
            {
                Name = "SuperSocketServer",
                Ip = "Any",
                Port = 2012,
                Mode = SocketMode.Tcp,
                MaxConnectionNumber = 100,
            };
            if (!appServer.Setup(serverConfig))
            {
                Console.WriteLine("Failed to set up!");
                return;
            }
            appServer.NewSessionConnected += NewSessionConnected;
            appServer.NewRequestReceived += NewRequestReceived;
            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 void NewSessionConnected(AppSession session)
        {
            Console.WriteLine($"New session connected: {session.SessionID}");
        }

        private static void NewRequestReceived(AppSession session, StringRequestInfo 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.");
            }
        }

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

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

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

    public class StringRequestFilterFactory : IRequestFilterFactory<StringRequestInfo>
    {
        public IRequestFilter<StringRequestInfo> CreateFilter(IAppServer appServer, IAppSession appSession, IPEndPoint remoteEndPoint)
        {
            return new TerminatorRequestFilterFactory().CreateFilter(appServer, appSession, remoteEndPoint);
        }
    }
}
using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
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 ServerConfig
            {
                Name = "SuperSocketServer",
                Ip = "Any",
                Port = 2012,
                Mode = SocketMode.Tcp,
                MaxConnectionNumber = 100,
            };
            if (!appServer.Setup(serverConfig))
            {
                Console.WriteLine("Failed to set up!");
                return;
            }
            appServer.NewSessionConnected += NewSessionConnected;
            appServer.NewRequestReceived += NewRequestReceived;
            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 void NewSessionConnected(AppSession session)
        {
            Console.WriteLine($"New session connected: {session.SessionID}");
        }

        private static void NewRequestReceived(AppSession session, StringRequestInfo 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.");
            }
        }

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

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

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

    public class StringRequestFilterFactory : IRequestFilterFactory<StringRequestInfo>
    {
        public IRequestFilter<StringRequestInfo> CreateFilter(IAppServer appServer, IAppSession appSession, IPEndPoint remoteEndPoint)
        {
            return new TerminatorRequestFilterFactory().CreateFilter(appServer, appSession, remoteEndPoint);
        }
    }
}

Esta integración le permite aprovechar las potentes funciones de IronPDF dentro de un servidor SuperSocket, posibilitando la generación dinámica de PDF y una eficaz comunicación cliente-servidor.

Conclusión

Información sobre licencias de IronPDF

Integración de SuperSocket con*funciones completas de IronPDF*** es una potente combinación para crear aplicaciones de servidor dinámicas y de alto rendimiento que pueden gestionar la generación y el procesamiento de PDF sin problemas. Con el robusto marco de servidores socket de SuperSocket y las completas funcionalidades PDF de IronPDF, podrá 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 un**Prueba gratuita, y su licencia comienza desde $749, brindando un excelente valor por las amplias capacidades que aporta a tus proyectos de desarrollo. Mediante la fusión de estas dos bibliotecas, puede agilizar la capacidad de su servidor para gestionar tareas complejas de manera eficiente, mejorando tanto la funcionalidad como el rendimiento.

Regan Pun
Regan Pun
  Chatea con el equipo de ingeniería ahora
Ingeniero de software
Regan se licenció en Ingeniería Electrónica por la Universidad de Reading. Antes de incorporarse a Iron Software, sus anteriores puestos de trabajo le obligaban a centrarse en tareas concretas; lo que más le gusta de Iron Software es la variedad de tareas que puede realizar, ya sea añadiendo valor a las ventas, el soporte técnico, el desarrollo de productos o el marketing. Le gusta entender cómo utilizan los desarrolladores la biblioteca de Iron Software y utilizar ese conocimiento para mejorar continuamente la documentación y desarrollar los productos.
< ANTERIOR
Quartz .NET (Cómo funciona para desarrolladores)
SIGUIENTE >
Dottrace .NET Core (Cómo funciona para desarrolladores)

Informar un Problema

¿Listo para empezar? Versión: 2025.3 acaba de salir

Empezar gratis
Descarga de NuGet Descarga DLL Instalador de Windows Iniciar prueba gratuita
Ver licencias >
Textlogo Iron Suite related to Ejemplo de Supersocket en C# (Cómo funciona para desarrolladores)

IronPDF forma parte de IRONSUITE

10 productos API de .NET para tus documentos de oficina

Obtén 10 productos por el precio de 2   Iniciar prueba gratuita