消息图标
跳至页脚内容
  1. IronPDF
  2. IronPDF博客
  3. .NET 帮助
  4. Supersocket C#
.NET 帮助

Supersocket C# 示例（开发人员如何使用）

Curtis Chau
Curtis Chau
已更新:

使用SuperSocket开发服务器端套接字应用程序并集成IronPDF

SuperSocket C#是开发服务器端套接字应用程序的优秀框架，无论您是在开发GPS服务器还是工业控制系统。 它支持各种网络协议的实现，确保您的套接字工作高效。 这是一个轻量级的跨平台框架，设计为可扩展，为不同环境提供灵活性。 使用SuperSocket，您可以轻松地在客户端和服务器之间发送数据，其源代码可用于定制以满足特定项目的需求。

这是一个开源框架，因此任何开发人员都可以通过GitHub实现和访问它。

SuperSocket C#示例（开发人员如何使用）：图1 - SuperSocket的GitHub页面

IronPDF是一个功能强大的.NET库，用于创建、编辑和提取PDF文档中的内容。 它专为需要在应用程序中集成PDF功能的开发人员设计。 IronPDF支持各种功能，如从HTML生成PDF，合并PDF，以及从PDF中提取文本和图像。

SuperSocket和IronPDF结合可以支持复杂的服务器端应用程序。 它们提供了广泛的功能，满足现代.NET开发人员的需求。 这些库非常适合于无论是构建数据采集服务器还是需要实时聊天应用的强大游戏服务器。

入门SuperSocket C

在.NET项目中设置SuperSocket C

要开始使用SuperSocket C#，您需要设置您的.NET项目。 首先，安装SuperSocket NuGet包。 在Visual Studio中打开您的项目，并在包管理器控制台中运行以下命令：

Install-Package SuperSocket

SuperSocket C#示例（开发人员如何使用）：图2 - 安装SuperSocket的控制台输出

安装后，您可以配置您的服务器实例。 创建一个名为appsettings.json的新配置文件。 该文件将定义服务器设置，包括监听器和协议。

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

接下来，创建一个类来配置服务器。 这个类将从appsettings.json中读取设置并初始化服务器实例。

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

一个基本的SuperSocket C#示例

让我们看看一个基本的SuperSocket C#应用程序示例。 此示例演示如何创建一个简单的回声服务器，将接收到的数据发送回去。

首先，定义会话类。 该类将处理套接字连接并管理数据通信。

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

接下来，配置并运行带有回声会话的服务器。

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

此示例展示了如何使用SuperSocket C#创建一个简单的回声服务器。 服务器监听连接并回显任何接收到的数据。

实现SuperSocket C#的功能

处理多个监听器

SuperSocket C#支持多个监听器，使您的服务器能够处理不同的协议和端口。 此功能对于创建多功能应用程序（如数据采集服务器和GPS服务器）非常有用。

首先，更新您的appsettings.json以包括多个监听器：

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

接下来，配置服务器以使用这些监听器：

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

通过此设置，您的服务器可以处理4040和5050端口上的连接。这一能力对于需要管理多种网络协议的应用程序至关重要。

实现二进制数据处理

SuperSocket C#在处理二进制数据方面非常高效。 这对于需要二进制级别兼容性的应用程序（如工业控制系统）至关重要。

首先，定义一个会话类来处理二进制数据：

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

接下来，配置并运行带有二进制数据会话的服务器：

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

此示例展示了如何使用SuperSocket C#接收和发送二进制数据。 它对于需要处理二进制协议的高性能应用程序非常有用。

管理套接字连接

维护套接字连接对于确保可靠通信至关重要。 SuperSocket C#简化了这一过程。

首先，定义管理套接字连接的会话类：

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

接下来，配置并运行带有连接会话的服务器：

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

此设置有助于管理套接字连接，确保您的服务器保持稳健和可靠。

创建命令行服务器

SuperSocket C#支持创建命令行服务器。 此功能对于需要简单文本协议的应用程序非常有用。

首先，定义一个处理文本命令的命令类：

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

接下来，配置服务器以使用该命令：

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

此示例展示了如何使用SuperSocket C#创建一个简单的命令行服务器。 它适用于轻量级文本协议。

Integrating SuperSocket C# with IronPDF

在您的C#应用程序中集成IronPDF和SuperSocket可以显著增强您的服务器能力，尤其是在处理PDF文件方面。 让我们探讨如何有效地合并这两个强大的库。

IronPDF简介

IronPDF网页

IronPDF .NET库是一个多功能的.NET库，用于创建、编辑和提取PDF文档中的内容。 无论您需要生成报告、发票还是任何其他基于PDF的文档，IronPDF提供了一个易于使用的API来完成这些任务。 其主要功能是其HTML到PDF转换能力。 对于希望在应用程序中集成PDF功能而不需处理PDF规范复杂性的开发人员来说，这是一个极好的工具。

IronPDF在HTML到PDF转换方面表现出色，确保精确保留原始布局和样式。 它非常适合从基于Web的内容中创建PDF，如报告、发票和文档。 利用对HTML文件、URL和原始HTML字符串的支持，IronPDF轻松生成高质量的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

合并IronPDF与SuperSocket C#的用例

想象一下，您有一个使用SuperSocket构建的服务器，需要动态处理客户端请求以生成和发送PDF文档。 通过集成IronPDF，您的服务器可以处理这些请求，动态生成PDF并将其无缝发送回客户端。

用例的代码示例

这是一个完整的代码示例，展示了如何将IronPDF与SuperSocket整合。 此示例设置了一个简单的SuperSocket服务器，该服务器监听客户端连接、处理生成PDF的请求，并将生成的PDF发送回客户端。

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

这种集成使您能够在SuperSocket服务器中利用IronPDF的强大特性，实现动态PDF生成和高效的客户端服务器通信。

结论

IronPDF许可信息

将SuperSocket与IronPDF的综合功能集成是创建动态、高性能服务器应用程序的强大组合，可以无缝处理PDF的生成和处理。 利用SuperSocket强大的套接字服务器框架和IronPDF的综合PDF功能，您可以开发可扩展和多功能的应用程序，以满足各种需求，从数据采集系统到游戏服务器和工业控制系统。

IronPDF提供免费试用版，其许可从$799开始，为您带来出色的价值，以便为您的开发项目带来广泛的功能。 通过合并这两个库，您可以简化服务器的复杂任务处理能力，同时提高功能和性能。

常见问题解答

SuperSocket C# 用于什么？

SuperSocket C# 用于开发服务器端套接字应用程序。它具有高度的可扩展性，支持多种网络协议，使其适用于诸如 GPS 服务器和工业控制系统的环境。

如何在.NET应用程序中将HTML转换为PDF？

您可以使用 IronPDF 的 RenderHtmlAsPdf 方法将 HTML 字符串转换为 PDF，并使用 RenderHtmlFileAsPdf 在 .NET 应用程序中将 HTML 文件转换为 PDF。

如何在 .NET 项目中设置 SuperSocket 服务器？

要在 .NET 项目中设置 SuperSocket 服务器，您需要安装 SuperSocket NuGet 包，使用 appsettings.json 文件配置服务器，并在您的应用程序代码中初始化服务器。

IronPDF 如何增强服务器端应用程序？

IronPDF 可以通过提供动态 PDF 生成和处理能力来增强服务器端应用程序，实现基于客户端请求的 PDF 文档实时创建和分发。

SuperSocket 能管理多个协议监听器吗？

是的，SuperSocket 可以管理多个协议监听器，允许一个服务器实例同时处理多种协议和端口，用于数据采集服务器等应用。

IronPDF 在处理 PDF 文档时有哪些优势？

IronPDF 提供了全面的功能来创建、编辑和提取 PDF 文档内容。它对于需要高级 PDF 文档处理和操作的应用程序来说是理想的选择。

SuperSocket 如何处理并发套接字连接？

SuperSocket 使用会话类来管理连接事件，确保可靠的通信和强大的服务器性能，即使在高负载下也是如此。

是否可以将 PDF 功能集成到 SuperSocket 应用程序中？

是的，通过在您的 SuperSocket 应用程序中集成 IronPDF，您可以添加 PDF 功能，如动态 PDF 生成和编辑，从而增强应用程序的功能。

SuperSocket 的常见使用场景是什么？

SuperSocket 的常见使用场景包括 GPS 服务器、工业控制系统、数据采集服务器和实时游戏服务器，所有这些都受益于高效和可靠的套接字通信。

我如何在 SuperSocket 中处理二进制数据？

SuperSocket 通过使用会话类来高效处理二进制数据，以处理传入的二进制数据包并发送响应，这对于需要二进制级数据处理的应用程序至关重要。

IronPDF 是否支持在服务器应用程序中进行 HTML 转 PDF 的转换？

是的，IronPDF 支持在服务器应用程序中进行 HTML 转 PDF 的转换，允许无缝地将 HTML 内容转化为高质量 PDF 文档。

Curtis Chau
Curtis Chau
  立即与工程团队聊天
技术作家

Curtis Chau 拥有卡尔顿大学的计算机科学学士学位，专注于前端开发，精通 Node.js、TypeScript、JavaScript 和 React。他热衷于打造直观且美观的用户界面，喜欢使用现代框架并创建结构良好、视觉吸引力强的手册。

除了开发之外，Curtis 对物联网 (IoT) 有浓厚的兴趣，探索将硬件和软件集成的新方法。在空闲时间，他喜欢玩游戏和构建 Discord 机器人，将他对技术的热爱与创造力相结合。

相关文章

30天试用 → 完整产品。无限制。无卡。 免费试用