SuperSocket C# é uma excelente estrutura para desenvolver aplicações de socket do lado do servidor, seja para um servidor GPS ou um sistema de controle industrial. Ele oferece suporte a diversas implementações de protocolos de rede e garante que seu socket funcione de forma eficiente. Essa estrutura multiplataforma leve foi projetada para ser extensível, oferecendo flexibilidade para diferentes ambientes. Com o SuperSocket, você pode enviar dados facilmente entre clientes e servidores, e seu código-fonte está disponível para personalização, atendendo aos requisitos específicos de cada projeto.
É um framework de código aberto, portanto qualquer desenvolvedor pode implementá-lo e acessá-lo através do GitHub.
IronPDF é uma poderosa biblioteca .NET para criar, editar e extrair conteúdo de documentos PDF. Ele foi projetado para desenvolvedores que precisam integrar a funcionalidade de PDF em seus aplicativos. O IronPDF oferece suporte a vários recursos, como geração de PDFs a partir de HTML, mesclagem de PDFs e extração de texto e imagens de PDFs.
O SuperSocket e o IronPDF, juntos, podem alimentar aplicações complexas do lado do servidor. Eles oferecem uma ampla gama de funcionalidades para atender às necessidades dos desenvolvedores .NET modernos. Essas bibliotecas são perfeitas tanto para a criação de um servidor de aquisição de dados quanto para um servidor de jogos robusto onde aplicativos de bate-papo em tempo real são necessários.
Para começar a usar o SuperSocket C#, você precisa configurar seu projeto .NET . Primeiro, instale o pacote NuGet SuperSocket. Abra seu projeto no Visual Studio e execute o seguinte comando no Console do Gerenciador de Pacotes:
Após a instalação, você poderá configurar sua instância de servidor. Crie um novo arquivo de configuração chamado appsettings.json. Este arquivo definirá as configurações do servidor, incluindo os ouvintes e os protocolos.
{
"serverOptions": {
"name": "SuperSocketServer",
"listeners": [
{
"ip": "Any",
"port": 4040
}
]
}
}Em seguida, crie uma classe para configurar o servidor. Esta classe irá ler as configurações de appsettings.json e inicializar a instância do 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();
}
}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 ClassVamos analisar um exemplo básico de uma aplicação SuperSocket em C#. Este exemplo demonstra como criar um servidor de eco simples que reenvia quaisquer dados recebidos.
Primeiro, defina a classe de sessão. Esta classe irá lidar com as conexões de soquete e gerenciar a comunicação de dados.
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 ClassEm seguida, configure e execute o servidor com a sessão 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();
}
}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 ClassEste exemplo mostra como criar um servidor de eco simples usando SuperSocket C#. O servidor fica à escuta de conexões e ecoa todos os dados que recebe.
O SuperSocket C# suporta múltiplos listeners, permitindo que seu servidor lide com diferentes protocolos e portas. Essa funcionalidade é útil para criar aplicações versáteis, como servidores de aquisição de dados e servidores GPS.
Primeiro, atualize seu appsettings.json para incluir múltiplos ouvintes:
{
"serverOptions": {
"name": "MultiListenerServer",
"listeners": [
{
"ip": "Any",
"port": 4040
},
{
"ip": "Any",
"port": 5050
}
]
}
}Em seguida, configure o servidor para usar esses ouvintes:
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 ClassCom essa configuração, seu servidor pode lidar com conexões nas portas 4040 e 5050. Essa capacidade é crucial para aplicativos que precisam gerenciar vários protocolos de rede.
O SuperSocket C# é eficiente no tratamento de dados binários. Isso é importante para aplicações que exigem compatibilidade em nível binário, como sistemas de controle industrial.
Primeiro, defina uma classe de sessão que processe dados binários:
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 ClassEm seguida, configure e execute o servidor com a sessão de dados binários:
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 ClassEste exemplo demonstra como receber e enviar dados binários usando o SuperSocket em C#. É útil para aplicações de alto desempenho que precisam processar protocolos binários.
Manter as conexões das tomadas em bom estado é essencial para garantir uma comunicação confiável. O SuperSocket C# simplifica esse processo.
Primeiro, defina uma classe de sessão que gerencie as conexões de soquete:
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 ClassEm seguida, configure e execute o servidor com a sessão de conexão:
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 ClassEssa configuração ajuda a gerenciar as conexões de soquete, garantindo que seu servidor permaneça robusto e confiável.
O SuperSocket C# oferece suporte à criação de servidores de linha de comando. Essa funcionalidade é útil para aplicações que requerem protocolos simples baseados em texto.
Primeiro, defina uma classe de comando que processe 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)}"));
}
}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 ClassEm seguida, configure o servidor para usar o 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();
}
}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 ClassEste exemplo mostra como criar um servidor de linha de comando simples usando SuperSocket C#. É ideal para protocolos leves baseados em texto.
A integração do IronPDF com o SuperSocket em suas aplicações C# pode aprimorar significativamente os recursos do seu servidor, especialmente no que diz respeito ao processamento de arquivos PDF. Vamos explorar como combinar essas duas bibliotecas poderosas de forma eficaz.
A biblioteca IronPDF .NET é uma biblioteca .NET versátil, projetada para criar, editar e extrair conteúdo de documentos PDF. Seja para gerar relatórios, faturas ou qualquer outro documento em PDF, o IronPDF oferece uma API fácil de usar para realizar essas tarefas. Sua principal característica é a capacidade de converter HTML em PDF . É uma ótima ferramenta para desenvolvedores que desejam incorporar a funcionalidade de PDF em seus aplicativos sem lidar com as complexidades das especificações de PDF.
O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.
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 ClassImagine que você tem um servidor construído com SuperSocket que precisa lidar com solicitações de clientes para gerar e enviar documentos PDF dinamicamente. Ao integrar o IronPDF, seu servidor pode processar essas solicitações, criar PDFs instantaneamente e enviá-los de volta aos clientes sem problemas.
Aqui está um exemplo de código completo demonstrando como integrar o IronPDF com o SuperSocket. Este exemplo configura um servidor SuperSocket simples que fica à escuta de conexões de clientes, processa uma solicitação para gerar um PDF e envia o PDF gerado de volta para o cliente.
using System;
using System.Net;
using System.Text;
using IronPdf;
using SuperSocket.SocketBase;
using SuperSocket.SocketBase.Protocol;
namespace SuperSocket IronPDFExample
{
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>
{
}
}Essa integração permite que você aproveite os poderosos recursos do IronPDF em um servidor SuperSocket, possibilitando a geração dinâmica de PDFs e uma comunicação eficiente entre cliente e servidor.
A integração do SuperSocket com os recursos abrangentes do IronPDF é uma combinação poderosa para a criação de aplicativos de servidor dinâmicos e de alto desempenho, capazes de lidar com a geração e o processamento de PDFs de forma integrada. Com a robusta estrutura de servidor de sockets do SuperSocket e as funcionalidades abrangentes de PDF do IronPDF, você pode desenvolver aplicações escaláveis e versáteis para atender a diversas necessidades, desde sistemas de aquisição de dados a servidores de jogos e sistemas de controle industrial.
IronPDF oferece uma avaliação gratuita, e seu licenciamento começa a partir de $999, proporcionando excelente valor pelas capacidades extensivas que traz para seus projetos de desenvolvimento. Ao combinar essas duas bibliotecas, você pode otimizar a capacidade do seu servidor de lidar com tarefas complexas de forma eficiente, aprimorando tanto a funcionalidade quanto o desempenho.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
