.NET-HILFE

Supersocket C# Beispiel (Wie es für Entwickler funktioniert)

Veröffentlicht 1. Juli 2024

Teilen Sie:

Entwicklung einer serverseitigen Socket-Anwendung mit SuperSocket und Integration von IronPDF

SuperSocket C# ist ein hervorragendes Framework für die Entwicklung einer serverseitigen Socket-Anwendung, egal ob Sie an einem GPS-Server oder einem industriellen Steuerungssystem arbeiten. Es unterstützt verschiedene Netzwerkprotokoll-Implementierungen und sorgt dafür, dass Ihr Socket effizient arbeitet. Dieses leichtgewichtige, plattformübergreifende Framework ist so konzipiert, dass es erweiterbar ist und Flexibilität für verschiedene Umgebungen bietet. Mit SuperSocket können Sie problemlos Daten zwischen Clients und Servern senden. Der Quellcode ist für die Anpassung an spezifische Projektanforderungen verfügbar.

Es handelt sich um ein Open-Source-Framework, so dass jeder Entwickler es über GitHub implementieren und darauf zugreifen kann.

SuperSocket C# Beispiel (Wie es für Entwickler funktioniert): Abbildung 1 - GitHub-Seite für SuperSocket

IronPDF ist eine leistungsstarke .NET-Bibliothek zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dokumenten. Es ist für Entwickler gedacht, die PDF-Funktionen 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.

SuperSocket und IronPDF können zusammen komplexe serverseitige Anwendungen betreiben. Sie bieten eine breite Palette von Funktionalitäten, die den Anforderungen moderner .NET-Entwickler entsprechen. Diese Bibliotheken eignen sich perfekt für den Aufbau eines Datenerfassungsservers oder eines robusten Spieleservers, für den Echtzeit-Chat-Anwendungen erforderlich sind.

Erste Schritte mit SuperSocket C

Einrichten von SuperSocket C# in .NET-Projekten

Um SuperSocket C# verwenden zu können, müssen Sie Ihr .NET-Projekt einrichten. Installieren Sie zunächst das SuperSocket NuGet-Paket. Öffnen Sie Ihr Projekt in Visual Studio und führen Sie den folgenden Befehl in der Paketmanager-Konsole aus:

Install-Package SuperSocket

SuperSocket C# Beispiel (Wie es für Entwickler funktioniert): Abbildung 2 - Konsolenausgabe nach der Installation von SuperSocket

Nach der Installation können Sie Ihre Serverinstanz konfigurieren. Erstellen Sie eine neue Konfigurationsdatei mit dem Namen appsettings.json. Diese Datei definiert die Servereinstellungen, einschließlich der Listener und Protokolle.

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

Als nächstes erstellen Sie eine Klasse zur Konfiguration des Servers. Diese Klasse liest die Einstellungen aus appsettings.json und initialisiert die Serverinstanz.

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

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

VB C#

Ein grundlegendes SuperSocket C# Beispiel

Schauen wir uns ein einfaches Beispiel für eine SuperSocket C# Anwendung an. Dieses Beispiel zeigt, wie man einen einfachen Echo-Server erstellt, der alle empfangenen Daten zurücksendet.

Definieren Sie zunächst die Sitzungsklasse. Diese Klasse behandelt die Socket-Verbindungen und verwaltet die Datenkommunikation.

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

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

VB C#

Als nächstes konfigurieren und starten Sie den Server mit der Echo-Sitzung.

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

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

VB C#

Dieses Beispiel zeigt, wie man einen einfachen Echo-Server mit SuperSocket C# erstellt. Der Server wartet auf Verbindungen und sendet alle empfangenen Daten als Echo zurück.

Implementieren der Funktionen von SuperSocket C

Umgang mit mehreren Zuhörern

SuperSocket C# unterstützt mehrere Listener, so dass Ihr Server mit verschiedenen Protokollen und Ports umgehen 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 Zuhörer einzubeziehen:

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

Als Nächstes konfigurieren Sie den Server für die Verwendung dieser Listener:

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

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

VB C#

Mit dieser Einstellung kann Ihr Server Verbindungen an den beiden Ports 4040 und 5050 verarbeiten. Diese Fähigkeit ist entscheidend für Anwendungen, die verschiedene Netzwerkprotokolle verwalten müssen.

Implementierung der Verarbeitung binärer Daten

SuperSocket C# ist effizient im Umgang mit Binärdaten. Dies ist wichtig für Anwendungen, die eine Kompatibilität auf binärer Ebene erfordern, wie z. B. industrielle Steuerungssysteme.

Definieren Sie zunächst eine Sitzungsklasse, die Binärdaten verarbeitet:

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

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

VB C#

Als nächstes konfigurieren und starten Sie den Server mit der Binärdatensitzung:

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

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

VB C#

Dieses Beispiel zeigt, wie man mit SuperSocket C# binäre Daten empfängt und sendet. Es ist nützlich für Hochleistungsanwendungen, die Binärprotokolle verarbeiten müssen.

Socket-Verbindungen verwalten

Die Aufrechterhaltung von Socket-Verbindungen ist für die Gewährleistung einer zuverlässigen Kommunikation unerlässlich. SuperSocket C# vereinfacht diesen Prozess.

Definieren Sie zunächst eine Sitzungsklasse, die Socket-Verbindungen verwaltet:

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

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

VB C#

Als nächstes konfigurieren und starten Sie den Server mit der Verbindungssitzung:

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

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

VB C#

Diese Einrichtung hilft bei der Verwaltung von Socket-Verbindungen und sorgt dafür, dass Ihr Server stabil und zuverlässig bleibt.

Erstellen eines Befehlszeilenservers

SuperSocket C# unterstützt die Erstellung von Befehlszeilenservern. Diese Funktion ist nützlich für Anwendungen, die einfache textbasierte Protokolle erfordern.

Definieren Sie zunächst eine Befehlsklasse, die Textbefehle verarbeitet:

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

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

VB C#

Konfigurieren Sie dann den Server für die Verwendung des Befehls:

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

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

VB C#

Dieses Beispiel zeigt, wie man einen einfachen Befehlszeilenserver mit SuperSocket C# erstellt. Es ist ideal für leichtgewichtige textbasierte Protokolle.

Integration von SuperSocket C# mit IronPDF

Die Integration von IronPDF mit SuperSocket in Ihre C#-Anwendungen kann Ihre Server-Fähigkeiten erheblich verbessern, insbesondere wenn es um die Handhabung von PDF-Dateien geht. Lassen Sie uns untersuchen, wie Sie diese beiden leistungsstarken Bibliotheken effektiv zusammenführen können.

Einführung in IronPDF

IronPDF-Webseite

IronPDF for .NET Library ist eine vielseitige .NET-Bibliothek zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dokumenten. Egal, ob Sie Berichte, Rechnungen oder andere PDF-basierte Dokumente erstellen müssen, IronPDF bietet eine benutzerfreundliche API, um diese Aufgaben zu bewältigen. Sein Hauptmerkmal ist seineHTML-zu-PDF-Konvertierung fähigkeiten. Es ist ein hervorragendes Werkzeug für Entwickler, die PDF-Funktionen in ihre Anwendungen integrieren möchten, ohne sich mit den komplexen PDF-Spezifikationen auseinandersetzen zu müssen.

Anwendungsfall der Zusammenführung von IronPDF mit SuperSocket C

Stellen Sie sich vor, Sie haben einen mit SuperSocket aufgebauten Server, der Client-Anfragen zur dynamischen Erzeugung und Versendung von PDF-Dokumenten verarbeiten muss. Durch die Integration von IronPDF kann Ihr Server diese Anfragen verarbeiten, PDFs im laufenden Betrieb erstellen und sie nahtlos an die Kunden zurücksenden.

Code-Beispiel für einen Anwendungsfall

Hier ist ein komplettes Code-Beispiel, das zeigt, wie IronPDF in SuperSocket integriert werden kann. In diesem Beispiel wird ein einfacher SuperSocket-Server eingerichtet, der auf Client-Verbindungen wartet, eine Anfrage zur Erzeugung einer PDF-Datei verarbeitet und die erzeugte PDF-Datei an den Client zurückschickt.

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

Imports System
Imports System.IO
Imports System.Net
Imports System.Net.Sockets
Imports System.Text
Imports System.Threading.Tasks
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 As New ServerConfig With {
				.Name = "SuperSocketServer",
				.Ip = "Any",
				.Port = 2012,
				.Mode = 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, AddressOf NewRequestReceived
			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 Sub NewSessionConnected(ByVal session As AppSession)
			Console.WriteLine($"New session connected: {session.SessionID}")
		End Sub

		Private Shared Sub NewRequestReceived(ByVal session As AppSession, ByVal requestInfo As StringRequestInfo)
			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

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

	Public Class AppServer
		Inherits AppServer(Of AppSession, StringRequestInfo)

	End Class

	Public Class AppSession
		Inherits AppSession(Of AppSession, StringRequestInfo)

	End Class

	Public Class StringRequestFilterFactory
		Implements IRequestFilterFactory(Of StringRequestInfo)

		Public Function CreateFilter(ByVal appServer As IAppServer, ByVal appSession As IAppSession, ByVal remoteEndPoint As IPEndPoint) As IRequestFilter(Of StringRequestInfo)
			Return (New TerminatorRequestFilterFactory()).CreateFilter(appServer, appSession, remoteEndPoint)
		End Function
	End Class
End Namespace

VB C#

Diese Integration ermöglicht es Ihnen, die leistungsstarken Funktionen von IronPDF innerhalb eines SuperSocket-Servers zu nutzen, was eine dynamische PDF-Erzeugung und eine effiziente Client-Server-Kommunikation ermöglicht.

Schlussfolgerung

IronPDF-Lizenzierungsinformationen

Integration von SuperSocket mitUmfassende Funktionen von IronPDF ist eine leistungsstarke Kombination für die Erstellung dynamischer, hochleistungsfähiger Serveranwendungen, die die PDF-Erstellung und -Verarbeitung nahtlos verarbeiten können. Mit dem robusten Socket-Server-Framework von SuperSocket und den umfassenden PDF-Funktionen von IronPDF können Sie skalierbare und vielseitige Anwendungen entwickeln, die den unterschiedlichsten Anforderungen gerecht werden, von Datenerfassungssystemen über Spieleserver bis hin zu industriellen Steuerungssystemen.

IronPDF bietet einekostenlos testen, und die Lizenzierung beginnt bei $749, wodurch es ein hervorragendes Preis-Leistungs-Verhältnis für die umfangreichen Fähigkeiten bietet, die es Ihren Entwicklungsprojekten bringt. Durch die Zusammenführung dieser beiden Bibliotheken können Sie die Fähigkeit Ihres Servers zur effizienten Bewältigung komplexer Aufgaben optimieren und sowohl die Funktionalität als auch die Leistung verbessern.

< PREVIOUS
Quartz .NET (Wie es für Entwickler funktioniert)

NÄCHSTES >
Dottrace .NET Core (Wie es für Entwickler funktioniert)