SuperSocket C# ist ein ausgezeichnetes Framework zur Entwicklung serverseitiger Socket-Anwendungen, egal ob Sie an einem GPS-Server oder einem industriellen Steuerungssystem arbeiten. Es unterstützt verschiedene Netzwerkprotokollimplementierungen und sorgt dafür, dass Ihr Socket effizient funktioniert. Dieses leichtgewichtige, plattformübergreifende Framework ist darauf ausgelegt, erweiterbar zu sein und Flexibilität für unterschiedliche Umgebungen zu bieten. Mit SuperSocket können Sie problemlos Daten zwischen Clients und Servern senden, und der Quellcode steht zur Anpassung an spezifische Projektanforderungen zur Verfügung.
Es ist ein Open-Source-Framework, d. h. jeder Entwickler kann es implementieren und über GitHub darauf zugreifen.
IronPDF ist eine leistungsstarke .NET-Bibliothek zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dokumenten. Es ist für Entwickler konzipiert, die PDF-Funktionalität in ihre Anwendungen integrieren müssen. IronPDF unterstützt verschiedene Funktionen wie das Erzeugen von PDFs aus HTML, das Zusammenführen von PDFs und das Extrahieren von Text und Bildern aus PDFs.
Zusammen können SuperSocket und IronPDF komplexe serverseitige Anwendungen betreiben. Sie bieten eine breite Palette von Funktionalitäten, um den Bedürfnissen moderner .NET-Entwickler gerecht zu werden. Diese Bibliotheken sind ideal, egal ob Sie einen Datenerfassungsserver bauen oder einen robusten Spielserver, bei dem Echtzeit-Chat-Anwendungen erforderlich sind.
Um mit der Verwendung von SuperSocket C# zu beginnen, müssen Sie Ihr .NET-Projekt einrichten. Zuerst das SuperSocket NuGet-Paket installieren. Öffnen Sie Ihr Projekt in Visual Studio und führen Sie den folgenden Befehl in der Paket-Manager-Konsole aus:
Sobald es installiert ist, können Sie Ihre Instanz des Servers konfigurieren. Erstellen Sie eine neue Konfigurationsdatei namens appsettings.json. Diese Datei definiert die Servereinstellungen, einschließlich der Listener und Protokolle.
{
"serverOptions": {
"name": "SuperSocketServer",
"listeners": [
{
"ip": "Any",
"port": 4040
}
]
}
}Erstellen Sie eine Klasse zur Serverkonfiguration. Diese Klasse wird die Einstellungen aus appsettings.json lesen und die Serverinstanz initialisieren.
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 ClassLassen Sie uns ein einfaches Beispiel für eine SuperSocket C# Anwendung ansehen. Dieses Beispiel demonstriert, wie man einen einfachen Echo-Server erstellt, der alle empfangenen Daten zurücksendet.
Definieren Sie zuerst die Sitzungs-Klasse. Diese Klasse verwaltet die Socketverbindungen und steuert die Datenkommunikation.
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 ClassKonfigurieren und starten Sie als Nächstes den Server mit der Echo-Sitzung.
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 ClassDieses Beispiel zeigt, wie man einen einfachen Echo-Server mit SuperSocket C# erstellt. Der Server lauscht auf Verbindungen und gibt alle empfangenen Daten zurück.
SuperSocket C# unterstützt mehrere Listener, sodass Ihr Server verschiedene Protokolle und Ports handhaben kann. Diese Funktion ist nützlich für die Erstellung vielseitiger Anwendungen wie Datenerfassungsserver und GPS-Server.
Aktualisieren Sie zunächst Ihre appsettings.json, um mehrere Listener einzuschließen:
{
"serverOptions": {
"name": "MultiListenerServer",
"listeners": [
{
"ip": "Any",
"port": 4040
},
{
"ip": "Any",
"port": 5050
}
]
}
}Konfigurieren Sie als Nächstes den Server, um diese Listener zu verwenden:
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 ClassMit diesem Setup kann Ihr Server Verbindungen auf beiden Ports 4040 und 5050 handhaben. Diese Fähigkeit ist entscheidend für Anwendungen, die verschiedene Netzwerkprotokolle verwalten müssen.
SuperSocket C# ist effizient bei der Handhabung von Binärdaten. Dies ist wichtig für Anwendungen, die Binärkompatibilität auf unterster Ebene erfordern, wie industrielle Steuerungssysteme.
Definieren Sie zuerst eine Sitzungs-Klasse, die Binärdaten verarbeitet:
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 ClassKonfigurieren Sie als Nächstes den Server mit der Binärdatensitzung und starten Sie ihn:
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 ClassDieses Beispiel demonstriert, wie man Binärdaten mit SuperSocket C# empfängt und sendet. Es ist nützlich für Hochleistungsanwendungen, die Binärprotokolle verarbeiten müssen.
Die Aufrechterhaltung von Socket-Verbindungen ist entscheidend für die Gewährleistung einer zuverlässigen Kommunikation. SuperSocket C# vereinfacht diesen Prozess.
Definieren Sie zuerst eine Sitzungs-Klasse, die Socket-Verbindungen verwaltet:
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 ClassKonfigurieren und starten Sie als Nächstes den Server mit der Verbindungssitzung:
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 ClassDieses Setup hilft bei der Verwaltung von Socket-Verbindungen und stellt sicher, dass Ihr Server robust und zuverlässig bleibt.
SuperSocket C# unterstützt die Erstellung von Konsolenzeilen-Servern. Diese Funktion ist nützlich für Anwendungen, die einfache textbasierte Protokolle erfordern.
Definieren Sie zuerst eine Befehls-Klasse, die Textbefehle verarbeitet:
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 ClassKonfigurieren Sie als Nächstes den Server, um den Befehl zu nutzen:
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 ClassDieses Beispiel zeigt, wie man einen einfachen Konsolenzeilen-Server mit SuperSocket C# erstellt. Es ist ideal für leichte textbasierte Protokolle.
Die Integration von IronPDF mit SuperSocket in Ihren C# Anwendungen kann Ihre Serverfähigkeiten erheblich erweitern, insbesondere wenn es um die Handhabung von PDF-Dateien geht. Lassen Sie uns erkunden, wie man diese zwei leistungsstarken Bibliotheken effektiv zusammenführt.
IronPDF for .NET-Bibliothek ist eine vielseitige .NET-Bibliothek, die für das Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dokumenten entwickelt wurde. Ob Sie Berichte, Rechnungen oder andere PDF-basierte Dokumente erstellen müssen, IronPDF bietet eine einfache API, um diese Aufgaben zu erledigen. Sein Hauptmerkmal ist seine HTML-zu-PDF-Konvertierung Fähigkeiten. Es ist ein großartiges Werkzeug für Entwickler, die PDF-Funktionalität in ihre Anwendungen einbauen möchten, ohne sich mit den Komplexitäten der PDF-Spezifikationen auseinanderzusetzen.
IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.
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 ClassStellen Sie sich vor, Sie haben einen Server mit SuperSocket erstellt, der Clientanfragen zur dynamischen Erstellung und zum Versand von PDF-Dokumenten bearbeiten muss. Durch die Integration von IronPDF kann Ihr Server diese Anfragen verarbeiten, PDFs im Handumdrehen erstellen und nahtlos an die Clients zurücksenden.
Hier ist ein vollständiges Codebeispiel, das zeigt, wie man IronPDF mit SuperSocket integriert. Dieses Beispiel richtet einen einfachen SuperSocket-Server ein, der auf Clientverbindungen hört, eine Anfrage zur Erstellung eines PDFs verarbeitet und das erstellte PDF zurück an den Client sendet.
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>
{
}
}Diese Integration ermöglicht es Ihnen, die leistungsstarken Funktionen von IronPDF innerhalb eines SuperSocket-Servers zu nutzen, um dynamische PDF-Generierung und effiziente Client-Server-Kommunikation zu ermöglichen.
Die Integration von SuperSocket mit IronPDF's umfassenden Funktionen ist eine leistungsstarke Kombination zur Erstellung dynamischer, leistungsfähiger Serveranwendungen, die eine nahtlose PDF-Erstellung und -Verarbeitung ermöglichen. Mit dem robusten Socketserver-Framework von SuperSocket und den umfassenden PDF-Funktionen von IronPDF können Sie skalierbare und vielseitige Anwendungen entwickeln, um verschiedene Anforderungen zu erfüllen, von Datenerfassungssystemen über Spieleserver bis hin zu industriellen Steuerungssystemen.
IronPDF bietet eine kostenlose Testversion an, und seine Lizenzierung beginnt bei $999 und bietet ein hervorragendes Preis-Leistungs-Verhältnis für die umfangreichen Fähigkeiten, die es in Ihre Entwicklungsprojekte einbringt. Durch die Zusammenführung dieser beiden Bibliotheken können Sie die Fähigkeit Ihres Servers zur effizienten Handhabung komplexer Aufgaben straffen und sowohl die Funktionalität als auch die Leistung verbessern.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
