SuperSocket C# to doskonałe narzędzie do tworzenia aplikacji serwerowych socket, niezależnie od tego, czy pracujesz nad serwerem GPS, czy systemem sterowania przemysłowego. Obsługuje różne implementacje protokołów sieciowych i zapewnia, że Twój socket działa wydajnie. Jest to lekki, wielopłatformowy framework, który został zaprojektowany, aby być rozbudowanym, zapewniając elastyczność dla różnych środowisk. Za pomocą SuperSocket możesz łatwo przesyłać dane między klientami a serwerami, a jego kod źródłowy jest dostępny do dostosowania do określonych wymagań projektu.
Jest to framework open-source, więc każdy programista może go zaimplementować i uzyskać do niego dostęp przez GitHub.
IronPDF to potężna biblioteka .NET do tworzenia, edytowania i wyodrębniania treści z dokumentów PDF. Jest przeznaczona dla programistów, którzy potrzebują zintegrować funkcjonalność PDF w swoich aplikacjach. IronPDF obsługuje różne funkcje, takie jak generowanie PDF z HTML, scałanie PDF i wyodrębnianie tekstu i obrazów z PDF.
SuperSocket i IronPDF razem mogą zasilać złożone aplikacje serwerowe. Oferują szeroką gamę funkcji, aby sprostać potrzebom współczesnych programistów .NET. Te biblioteki są idealne zarówno do budowy serwera akwizycji danych, jak i solidnego serwera gier, gdzie aplikacje czatu w czasie rzeczywistym są koniecznością.
Aby zacząć korzystać z SuperSocket C#, musisz skonfigurować swój projekt .NET. Najpierw zainstaluj pakiet SuperSocket NuGet. Otwórz swój projekt w Visual Studio i wykonaj następujące polecenie w konsoli Menedżera Pakietów:
Po zainstalowaniu możesz skonfigurować instancję serwera. Utworz nowy plik konfiguracyjny o nazwie appsettings.json. Ten plik zdefiniuje ustawienia serwera, w tym słuchaczy i protokoły.
{
"serverOptions": {
"name": "SuperSocketServer",
"listeners": [
{
"ip": "Any",
"port": 4040
}
]
}
}Następnie utwórz klasę do konfiguracji serwera. Ta klasa odczyta ustawienia z appsettings.json i zainicjalizuje instancje serwera.
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 ClassSpójrzmy na podstawowy przykład aplikacji SuperSocket C#. Ten przykład pokazuje, jak stworzyć prosty serwer echo, który odsyła dowolne odebrane dane.
Najpierw zdefiniuj klasę sesji. Ta klasa będzie obsługiwać połączenia socket i zarządzać komunikacją danych.
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 ClassNastępnie skonfiguruj i uruchom serwer z sesją echo.
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 ClassTen przykład pokazuje, jak stworzyć prosty serwer echo przy użyciu SuperSocket C#. Serwer nasłuchuje połączeń i odsyła każde otrzymane dane.
SuperSocket C# obsługuje wielu słuchaczy, pozwalając Twojemu serwerowi obsługiwać różne protokoły i porty. Ta funkcja jest przydatna przy tworzeniu wszechstronnych aplikacji, takich jak serwery akwizycji danych i serwery GPS.
Najpierw zaktualizuj swoj appsettings.json, aby dodac wielu sluchaczy:
{
"serverOptions": {
"name": "MultiListenerServer",
"listeners": [
{
"ip": "Any",
"port": 4040
},
{
"ip": "Any",
"port": 5050
}
]
}
}Następnie skonfiguruj serwer do użycia tych słuchaczy:
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 ClassDzięki tej konfiguracji Twój serwer może obsługiwać połączenia na obu portach 4040 i 5050. Ta zdolność jest kluczowa dla aplikacji, które muszą zarządzać różnymi protokołami sieciowymi.
SuperSocket C# jest efektywny w obsłudze danych binarnych. To ważne dla aplikacji, które wymagają zgodności na poziomie binarnym, takich jak systemy sterowania przemysłowego.
Najpierw zdefiniuj klasę sesji, która przetwarza dane binarne:
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 ClassNastępnie skonfiguruj i uruchom serwer z sesją danych binarnych:
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 ClassTen przykład pokazuje, jak odbierać i wysyłać dane binarne przy użyciu SuperSocket C#. Jest to przydatne dla aplikacji wysokowydajnościowych, które muszą przetwarzać protokoły binarne.
Utrzymanie połączeń socket jest niezbędne do zapewnienia niezawodnej komunikacji. SuperSocket C# upraszcza ten proces.
Najpierw zdefiniuj klasę sesji, która zarządza połączeniami 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);
}
}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 ClassNastępnie skonfiguruj i uruchom serwer z sesją połączeń:
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 ClassTa konfiguracja pomaga zarządzać połączeniami socket, zapewniając, że Twój serwer pozostaje robustny i niezawodny.
SuperSocket C# obsługuje tworzenie serwerów wiersza poleceń. Ta funkcja jest przydatna dla aplikacji, które wymagają prostych protokołów tekstowych.
Najpierw zdefiniuj klasę poleceń, która przetwarza polecenia tekstowe:
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 ClassNastępnie skonfiguruj serwer do użycia polecenia:
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 ClassTen przykład pokazuje, jak stworzyć prosty serwer wiersza poleceń przy użyciu SuperSocket C#. Idealny dla lekkich protokołów tekstowych.
Integracja IronPDF z SuperSocket w swoich aplikacjach C# może znacznie zwiększyć możliwości serwera, zwłaszcza jeśli chodzi o obsługę plików PDF. Przyjrzyjmy się, jak skutecznie połączyć te dwa potężne narzędzia.
IronPDF .NET Library to wszechstronna biblioteka .NET przeznaczona do tworzenia, edytowania i wyodrębniania treści z dokumentów PDF. Niezależnie od tego, czy potrzebujesz generować raporty, faktury, czy jakiekolwiek inne dokumenty na bazie PDF, IronPDF zapewnia łatwe w użyciu API do realizacji tych zadań. Jej główną cechą są możliwości konwersji HTML do PDF. To świetne narzędzie dla programistów, którzy chcą włączyć funkcjonalność PDF do swoich aplikacji, bez zajmowania się zawiłościami specyfikacji PDF.
IronPDF wyróżnia się w konwersji HTML do PDF, zapewniając precyzyjne zachowanie oryginalnych układów i stylów. Idealnie nadaje się do tworzenia plików PDF z treści internetowych, takich jak raporty, faktury i dokumentacja. Dzięki obsłudze plików HTML, adresów URL i surowych ciągów znaków HTML, IronPDF z łatwością tworzy wysokiej jakości dokumenty 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 ClassWyobraź sobie, że masz serwer zbudowany przy użyciu SuperSocket, który musi obsługiwać żądania klientów dotyczące dynamicznego generowania i wysyłania dokumentów PDF. Poprzez integrację IronPDF, Twój serwer może przetwarzać te żądania, tworzyć PDF-y w locie i wysyłać je z powrotem do klientów bezproblemowo.
Oto kompletny przykład kodu pokazujący, jak zintegrować IronPDF z SuperSocket. Ten przykład ustawia prosty serwer SuperSocket, który nasłuchuje połączeń klienta, przetwarza żądanie dotyczące generowania PDF i wysyła wygenerowany PDF z powrotem do klienta.
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>
{
}
}Ta integracja pozwala na wykorzystanie potężnych funkcji IronPDF w serwerze SuperSocket, umożliwiając dynamiczne generowanie PDF i efektywną komunikację klient-serwer.
Integracja SuperSocket z kompleksowymi funkcjami IronPDF to potężne połączenie do tworzenia dynamicznych, wysokowydajnościowych aplikacji serwerowych, które mogą bezproblemowo obsługiwać generowanie i przetwarzanie PDF. Z solidnym frameworkiem serwera socket SuperSocket i kompleksowymi funkcjami PDF IronPDF, możesz rozwijać skalowalne i wszechstronne aplikacje, aby zaspokoić różnorodne potrzeby, od systemów akwizycji danych po serwery gier i systemy sterowania przemysłowego.
IronPDF oferuje bezplatna wersje probna, a jego licencjonowanie rozpoczyna sie od $999, zapewniajac doskonala wartosc za rozbudowane mozliwosci, jakie wnosi do twoich projektow deweloperskich. Poprzez połączenie tych dwóch bibliotek, możesz usprawnić zdolność serwera do efektywnego zarządzania złożonymi zadaniami, zwiększając zarówno funkcjonalność, jak i wydajność.
Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
