POMOC .NET

Przykład Supersocket C# (jak to działa dla programistów)

Q: Jak mogę przekonwertować HTML na PDF w aplikacji .NET?

Możesz użyć metody RenderHtmlAsPdf biblioteki IronPDF do konwersji ciągów HTML na pliki PDF oraz metody RenderHtmlFileAsPdf do konwersji plików HTML na pliki PDF w aplikacji .NET.

Jacob Mellor

Zaktualizowano:31 stycznia, 2026

Tworzenie aplikacji serwerowej socket przy użyciu SuperSocket i integracja z IronPDF

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

SuperSocket C# Example (Jak to działa dla deweloperów): Rysunek 1 - Strona GitHub dla SuperSocket

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, scalanie 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ą.

Getting Started with SuperSocket C

Konfiguracja SuperSocket C# w projektach .NET

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:

Install-Package SuperSocket

SuperSocket C# Example (Jak to działa dla deweloperów): Rysunek 2 - Konsola wyników po instalacji SuperSocket

Po zainstalowaniu możesz skonfigurować instancję serwera. Utwórz 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 będzie odczytywać ustawienia z appsettings.json i inicjalizować instancję 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();
    }
}

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

Podstawowy przykład SuperSocket C

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

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

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

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

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

Implementing Features of SuperSocket C

Obsługa wielu słuchaczy

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 swój appsettings.json, aby uwzględniał wielu słuchaczy:

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

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

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

Implementacja obsługi danych binarnych

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

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

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

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

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

Zarządzanie połączeniami socket

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

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

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

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

Ta konfiguracja pomaga zarządzać połączeniami socket, zapewniając, że Twój serwer pozostaje robustny i niezawodny.

Tworzenie serwera wiersza poleceń

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

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

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

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

Ten przykład pokazuje, jak stworzyć prosty serwer wiersza poleceń przy użyciu SuperSocket C#. Idealny dla lekkich protokołów tekstowych.

Integrating SuperSocket C# with IronPDF

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.

Wprowadzenie do IronPDF

Strona IronPDF

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

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

Use Case of Merging IronPDF with SuperSocket C

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

Przykład kodu dla przypadku użycia

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

Ta integracja pozwala na wykorzystanie potężnych funkcji IronPDF w serwerze SuperSocket, umożliwiając dynamiczne generowanie PDF i efektywną komunikację klient-serwer.

Wnioski

Informacje o licencjonowaniu IronPDF

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 bezpłatną wersję próbną, a jego licencjonowanie zaczyna się od $799, zapewniając doskonałą wartość za rozległe możliwości, które wnosi do Twoich projektów rozwojowych. 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ść.

Często Zadawane Pytania

Do czego służy SuperSocket C#?

SuperSocket C# służy do tworzenia aplikacji gniazdowych po stronie serwera. Jest wysoce rozszerzalny i obsługuje różne protokoły sieciowe, dzięki czemu nadaje się do środowisk takich jak serwery GPS i przemysłowe systemy sterowania.

Jak mogę przekonwertować HTML na PDF w aplikacji .NET?

Możesz użyć metody RenderHtmlAsPdf biblioteki IronPDF do konwersji ciągów HTML na pliki PDF oraz metody RenderHtmlFileAsPdf do konwersji plików HTML na pliki PDF w aplikacji .NET.

Jak skonfigurować serwer SuperSocket w projekcie .NET?

Aby skonfigurować serwer SuperSocket w projekcie .NET, należy zainstalować pakiet NuGet SuperSocket, skonfigurować serwer za pomocą pliku appsettings.json oraz zainicjować serwer w kodzie aplikacji.

W jaki sposób IronPDF może usprawnić działanie aplikacji po stronie serwera?

IronPDF może usprawnić działanie aplikacji po stronie serwera, zapewniając dynamiczne generowanie i przetwarzanie plików PDF, umożliwiając tworzenie i dystrybucję dokumentów PDF w czasie rzeczywistym na podstawie żądań klientów.

Czy SuperSocket może obsługiwać wiele odbiorników protokołów?

Tak, SuperSocket może zarządzać wieloma odbiornikami protokołów, umożliwiając pojedynczej instancji serwera obsługę różnych protokołów i portów jednocześnie dla aplikacji takich jak serwery gromadzenia danych.

Jakie korzyści oferuje IronPDF w zakresie obsługi dokumentów PDF?

IronPDF oferuje kompleksowe funkcje do tworzenia, edycji i wyodrębniania treści z dokumentów PDF. Jest idealnym rozwiązaniem dla aplikacji wymagających zaawansowanej obsługi i manipulacji dokumentami PDF.

W jaki sposób SuperSocket obsługuje równoczesne połączenia gniazdowe?

SuperSocket obsługuje równoczesne połączenia gniazdowe przy użyciu klas sesji do zarządzania zdarzeniami połączeń, zapewniając niezawodną komunikację i wysoką wydajność serwera nawet przy dużym obciążeniu.

Czy możliwe jest zintegrowanie funkcji PDF z aplikacjami SuperSocket?

Tak, integrując IronPDF z aplikacjami SuperSocket, można dodać funkcje związane z plikami PDF, takie jak dynamiczne generowanie i edycja plików PDF, zwiększając tym samym możliwości aplikacji.

Jakie są typowe zastosowania SuperSocket?

Typowe zastosowania SuperSocket obejmują serwery GPS, przemysłowe systemy sterowania, serwery gromadzenia danych oraz serwery gier działające w czasie rzeczywistym, z których wszystkie czerpią korzyści z wydajnej i niezawodnej komunikacji przez gniazda.

Jak mogę obsługiwać dane binarne w SuperSocket?

SuperSocket efektywnie obsługuje dane binarne, wykorzystując klasy sesji do przetwarzania przychodzących pakietów binarnych i wysyłania odpowiedzi, co jest niezbędne w aplikacjach wymagających przetwarzania danych na poziomie binarnym.

Czy IronPDF obsługuje konwersję HTML do PDF w aplikacjach serwerowych?

Tak, IronPDF obsługuje konwersję HTML do PDF w aplikacjach serwerowych, umożliwiając płynne przekształcanie treści HTML w wysokiej jakości dokumenty PDF.

Jacob Mellor

Czat z zespołem inżynierów teraz

Dyrektor ds. technologii

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

Czytaj więcej

Powiązane artykuły

Zaktualizowano 20 lutego, 2026

Łączenie prostoty CLI i .NET: Używanie Curl DotNet z IronPDF

Jacob Mellor przeskoczył tę lukę za pomocą CurlDotNet, biblioteki stworzonej w celu wprowadzenia znajomości cURL do ekosystemu .NET.

Czytaj więcej

Zaktualizowano 20 grudnia, 2025

RandomNumberGenerator C#

Korzystanie z klasy RandomNumberGenerator C# może pomóc przenieść projekty związane z generacją i edytowaniem PDF na wyższy poziom

Czytaj więcej

Zaktualizowano 20 grudnia, 2025

C# String Equals (Jak to działa dla deweloperów)

W połączeniu z potężną biblioteką PDF, taką jak IronPDF, dopasowanie wzorca umożliwia tworzenie mądrzejszej, bardziej czystej logiki do przetwarzania dokumentów

Czytaj więcej

Quartz .NET (jak to działa dla programistów)

Dottrace .NET Core (jak to działa ...

Zwyciestwo klienta:

Podkreslaj programiste:

SEMINARIA INTERNETOWE:

Rozpocznij Bezpłatny 30-dniowy Okres Próbny

Przykład Supersocket C# (jak to działa dla programistów)

Tworzenie aplikacji serwerowej socket przy użyciu SuperSocket i integracja z IronPDF

Getting Started with SuperSocket C

Konfiguracja SuperSocket C# w projektach .NET

Podstawowy przykład SuperSocket C

Implementing Features of SuperSocket C

Obsługa wielu słuchaczy

Implementacja obsługi danych binarnych

Zarządzanie połączeniami socket

Tworzenie serwera wiersza poleceń

Integrating SuperSocket C# with IronPDF

Wprowadzenie do IronPDF

Use Case of Merging IronPDF with SuperSocket C

Przykład kodu dla przypadku użycia

Wnioski

Często Zadawane Pytania

Do czego służy SuperSocket C#?

Jak mogę przekonwertować HTML na PDF w aplikacji .NET?

Jak skonfigurować serwer SuperSocket w projekcie .NET?

W jaki sposób IronPDF może usprawnić działanie aplikacji po stronie serwera?

Czy SuperSocket może obsługiwać wiele odbiorników protokołów?

Jakie korzyści oferuje IronPDF w zakresie obsługi dokumentów PDF?

W jaki sposób SuperSocket obsługuje równoczesne połączenia gniazdowe?

Czy możliwe jest zintegrowanie funkcji PDF z aplikacjami SuperSocket?

Jakie są typowe zastosowania SuperSocket?

Jak mogę obsługiwać dane binarne w SuperSocket?

Czy IronPDF obsługuje konwersję HTML do PDF w aplikacjach serwerowych?

Zespol wsparcia Iron

Rozpocznij Bezpłatny 30-dniowy Okres Próbny

Przykład Supersocket C# (jak to działa dla programistów)

Tworzenie aplikacji serwerowej socket przy użyciu SuperSocket i integracja z IronPDF

Getting Started with SuperSocket C

Konfiguracja SuperSocket C# w projektach .NET

Podstawowy przykład SuperSocket C

Implementing Features of SuperSocket C

Obsługa wielu słuchaczy

Implementacja obsługi danych binarnych

Zarządzanie połączeniami socket

Tworzenie serwera wiersza poleceń

Integrating SuperSocket C# with IronPDF

Wprowadzenie do IronPDF

Use Case of Merging IronPDF with SuperSocket C

Przykład kodu dla przypadku użycia

Wnioski

Często Zadawane Pytania

Do czego służy SuperSocket C#?

Jak mogę przekonwertować HTML na PDF w aplikacji .NET?

Jak skonfigurować serwer SuperSocket w projekcie .NET?

W jaki sposób IronPDF może usprawnić działanie aplikacji po stronie serwera?

Czy SuperSocket może obsługiwać wiele odbiorników protokołów?

Jakie korzyści oferuje IronPDF w zakresie obsługi dokumentów PDF?

W jaki sposób SuperSocket obsługuje równoczesne połączenia gniazdowe?

Czy możliwe jest zintegrowanie funkcji PDF z aplikacjami SuperSocket?

Jakie są typowe zastosowania SuperSocket?

Jak mogę obsługiwać dane binarne w SuperSocket?

Czy IronPDF obsługuje konwersję HTML do PDF w aplikacjach serwerowych?

Powiązane artykuły

Łączenie prostoty CLI i .NET: Używanie Curl DotNet z IronPDF

RandomNumberGenerator C#

C# String Equals (Jak to działa dla deweloperów)

Następny krok: Rozpocznij darmową 30-dniową wersję próbną

Następny krok: Rozpocznij darmową 30-dniową wersję próbną

Want to deploy IronSuite to a live project for FREE?

What’s included?

Zaufane przez miliony inżynierów na całym świecie

Zespol wsparcia Iron