Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET-Hilfe
  4. Supersocket in C#
.NET HILFE

Supersocket C# Beispiel (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

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

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.

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 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.

Einstieg mit SuperSocket C

Einrichten von SuperSocket C# in .NET-Projekten

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:

Install-Package SuperSocket

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

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 liest die Einstellungen aus appsettings.json und initialisiert die Instanz des Servers.

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();
    }
}
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 Class
$vbLabelText   $csharpLabel

Ein grundlegendes SuperSocket C# Beispiel

Lassen 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);
    }
}
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 Class
$vbLabelText   $csharpLabel

Konfigurieren 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();
    }
}
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 Class
$vbLabelText   $csharpLabel

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

Einführung der Funktionen von SuperSocket C

Behandlung mehrerer Listener

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 zuerst Ihr 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();
    }
}
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 Class
$vbLabelText   $csharpLabel

Mit 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.

Implementierung binärer Datenverarbeitung

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);
    }
}
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 Class
$vbLabelText   $csharpLabel

Konfigurieren 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();
    }
}
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 Class
$vbLabelText   $csharpLabel

Dieses 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.

Verwaltung von Socket-Verbindungen

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);
    }
}
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 Class
$vbLabelText   $csharpLabel

Konfigurieren 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();
    }
}
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 Class
$vbLabelText   $csharpLabel

Dieses Setup hilft bei der Verwaltung von Socket-Verbindungen und stellt sicher, dass Ihr Server robust und zuverlässig bleibt.

Erstellen eines Befehlszeilenservers

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)}"));
    }
}
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 Class
$vbLabelText   $csharpLabel

Konfigurieren 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();
    }
}
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 Class
$vbLabelText   $csharpLabel

Dieses Beispiel zeigt, wie man einen einfachen Konsolenzeilen-Server mit SuperSocket C# erstellt. Es ist ideal für leichte textbasierte Protokolle.

Integration von SuperSocket C# mit IronPDF

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.

Einführung in IronPDF

IronPDF Webseite

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");
    }
}
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 Class
$vbLabelText   $csharpLabel

Anwendungsfall der Zusammenführung von IronPDF mit SuperSocket C#

Stellen 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.

Code-Beispiel für Anwendungsfall

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 SuperSocketIronPDFExample
{
    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>
    {
    }
}
using System;
using System.Net;
using System.Text;
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 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>
    {
    }
}
Imports System
Imports System.Net
Imports System.Text
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 = New SuperSocket.SocketBase.Config.ServerConfig With {
				.Name = "SuperSocketServer",
				.Ip = "Any",
				.Port = 2012,
				.Mode = SuperSocket.SocketBase.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, Sub(session, requestInfo)
				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

			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 Function CreatePdfDocument(ByVal content As String) As PdfDocument
			Dim pdfRenderer = New ChromePdfRenderer()
			Dim pdfDocument = pdfRenderer.RenderHtmlAsPdf(content)
			Return pdfDocument
		End Function

		Private Shared Sub NewSessionConnected(ByVal session As AppSession)
			Console.WriteLine($"New session connected: {session.SessionID}")
		End Sub
	End Class

	Public Class AppServer
		Inherits AppServer(Of AppSession, StringRequestInfo)

	End Class

	Public Class AppSession
		Inherits AppSession(Of AppSession, StringRequestInfo)

	End Class
End Namespace
$vbLabelText   $csharpLabel

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.

Abschluss

IronPDF-Lizenzinformationen

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, und seine Lizenzierung beginnt ab $799, was ein ausgezeichnetes 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 Handhabung komplexer Aufgaben straffen und sowohl die Funktionalität als auch die Leistung verbessern.

Häufig gestellte Fragen

Wofür wird SuperSocket C# verwendet?

SuperSocket C# wird zur Entwicklung serverseitiger Socket-Anwendungen verwendet. Es ist hochgradig erweiterbar und unterstützt verschiedene Netzwerkprotokolle, was es für Umgebungen wie GPS-Server und industrielle Steuerungssysteme geeignet macht.

Wie kann ich HTML in einer .NET-Anwendung in PDF umwandeln?

Sie können die Methode RenderHtmlAsPdf von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren, und RenderHtmlFileAsPdf, um HTML-Dateien innerhalb einer .NET-Anwendung in PDFs umzuwandeln.

Wie richtet man einen SuperSocket-Server in einem .NET-Projekt ein?

Um einen SuperSocket-Server in einem .NET-Projekt einzurichten, müssen Sie das SuperSocket NuGet-Paket installieren, den Server mit einer appsettings.json-Datei konfigurieren und den Server innerhalb Ihres Anwendungscodes initialisieren.

Wie kann IronPDF serverseitige Anwendungen verbessern?

IronPDF kann serverseitige Anwendungen verbessern, indem es dynamische PDF-Generierungs- und Verarbeitungsfunktionen bereitstellt, die die Echtzeiterstellung und -verteilung von PDF-Dokumenten basierend auf Kundenanforderungen ermöglichen.

Kann SuperSocket mehrere Protokoll-Listener verwalten?

Ja, SuperSocket kann mehrere Protokoll-Listener verwalten, sodass eine einzelne Serverinstanz verschiedene Protokolle und Ports gleichzeitig für Anwendungen wie Datenerfassungsserver handhaben kann.

Welche Vorteile bietet IronPDF bei der Verarbeitung von PDF-Dokumenten?

IronPDF bietet umfassende Funktionen zur Erstellung, Bearbeitung und Extraktion von Inhalten aus PDF-Dokumenten. Es ist ideal für Anwendungen, die eine fortgeschrittene Verarbeitung und Manipulation von PDF-Dokumenten erfordern.

Wie handhabt SuperSocket gleichzeitige Socket-Verbindungen?

SuperSocket behandelt gleichzeitige Socket-Verbindungen mit Sitzungs-Klassen zur Verwaltung von Verbindungsvorgängen und gewährleistet so eine zuverlässige Kommunikation und solide Serverleistung, selbst unter hoher Last.

Ist es möglich, PDF-Funktionalitäten in SuperSocket-Anwendungen zu integrieren?

Ja, durch die Integration von IronPDF in Ihre SuperSocket-Anwendungen können Sie PDF-Funktionalitäten wie die dynamische PDF-Erstellung und -Bearbeitung hinzufügen, die die Fähigkeiten der Anwendung verbessern.

Was sind häufige Anwendungsfälle für SuperSocket?

Häufige Anwendungsfälle für SuperSocket sind GPS-Server, industrielle Steuerungssysteme, Datenerfassungsserver und Echtzeitspieleserver, die alle von einer effizienten und zuverlässigen Socket-Kommunikation profitieren.

Wie kann ich Binärdaten in SuperSocket verarbeiten?

SuperSocket verarbeitet Binärdaten effizient, indem es Sitzungs-Klassen verwendet, um eingehende Binärpakete zu verarbeiten und Antworten zu senden, was für Anwendungen, die eine Verarbeitung auf Binärebene erfordern, unerlässlich ist.

Unterstützt IronPDF die HTML-zu-PDF-Konvertierung in Serveranwendungen?

Ja, IronPDF unterstützt die HTML-zu-PDF-Konvertierung in Serveranwendungen und ermöglicht die nahtlose Umwandlung von HTML-Inhalten in hochwertige PDF-Dokumente.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen