메시지 아이콘
푸터 콘텐츠로 바로가기
  1. IronPDF
  2. IronPDF 블로그
  3. .NET 도움말
  4. Supersocket C#
.NET 도움말

SuperSocket C# 예제 (개발자를 위한 작동 방식)

제이콥 멜러, 팀 아이언 최고기술책임자
제이콥 멜러
업데이트됨:

SuperSocket과 IronPDF를 통합한 서버 측 소켓 애플리케이션 개발

SuperSocket C#는 GPS 서버나 산업 제어 시스템에서 작업할 때 서버 측 소켓 애플리케이션을 개발하기 위한 뛰어난 프레임워크입니다. 다양한 네트워크 프로토콜 구현을 지원하며 소켓이 효율적으로 작동하도록 보장합니다. 이 경량의 교차 플랫폼 프레임워크는 다양한 환경에 맞게 확장 가능하도록 설계되었습니다. SuperSocket을 사용하면 클라이언트와 서버 간에 데이터를 쉽게 전송할 수 있으며, 소스 코드는 특정 프로젝트 요구 사항에 맞게 사용자 정의할 수 있습니다.

오픈 소스 프레임워크이므로 모든 개발자가 GitHub를 통해 구현하고 접근할 수 있습니다.

SuperSocket C# 예제 (개발자를 위한 작동 방식): 그림 1 - GitHub 페이지에서 SuperSocket

IronPDF는 PDF 문서에서 콘텐츠를 생성, 편집, 추출하기 위한 강력한 .NET 라이브러리입니다. 애플리케이션에 PDF 기능을 통합해야 하는 개발자를 위해 설계되었습니다. IronPDF는 HTML에서 PDF 생성, PDF 병합, 텍스트 및 이미지 추출 등 다양한 기능을 지원합니다.

SuperSocket과 IronPDF는 함께 복잡한 서버 측 애플리케이션을 구동할 수 있습니다. 현대의 .NET 개발자의 요구를 충족시키기 위해 폭넓은 기능을 제공합니다. 데이터 수집 서버를 구축하든 실시간 채팅 애플리케이션이 필요한 강력한 게임 서버를 구축하든, 이러한 라이브러리는 완벽합니다.

Getting Started with 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#을 사용하여 간단한 에코 서버를 만드는 방법을 보여줍니다. 서버는 연결을 수신하고 수신된 데이터를 에코합니다.

Implementing Features of 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 라이브러리는 PDF 문서 생성, 편집, 콘텐츠 추출을 위해 설계된 다용도의 .NET 라이브러리입니다. 보고서, 청구서 또는 기타 PDF 기반 문서를 생성해야 할 때 IronPDF는 이러한 작업을 수행하기 위한 사용하기 쉬운 API를 제공합니다. HTML-TO-PDF 변환 기능이 주된 기능입니다. PDF 사양의 복잡성을 다루지 않고 응용 프로그램에 PDF 기능을 통합하려는 개발자에게 훌륭한 도구입니다.

IronPDF는 원래 레이아웃과 스타일을 정확히 보존하여 HTML을 PDF로 변환하는 데 탁월합니다. 보고서, 송장 및 설명서와 같은 웹 기반 콘텐츠에서 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

Use Case of Merging IronPDF with SuperSocket C

SuperSocket으로 빌드된 서버가 PDF 문서를 생성하고 클라이언트 요청에 응답하여 동적으로 보내야 하는 상황을 상상해 보십시오. IronPDF를 통합함으로써 서버는 이러한 요청을 처리하고, 실시간으로 PDF를 생성하고, 클라이언트에게 원활하게 다시 보낼 수 있습니다.

사용 사례 코드 예제

IronPDF와 SuperSocket을 통합하는 방법을 보여주는 완전한 코드 예제가 여기 있습니다. 이 예제는 클라이언트 연결을 듣고, PDF 생성을 요청을 처리하고, 생성된 PDF를 다시 클라이언트에게 보내는 간단한 SuperSocket 서버를 설정합니다.

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 라이선스 정보

IronPDF의 포괄적 기능과 SuperSocket 통합은 PDF 생성 및 처리를 원활하게 처리할 수 있는 동적이고 고성능 서버 응용 프로그램을 생성하는 데 강력한 조합입니다. SuperSocket의 견고한 소켓 서버 프레임워크와 IronPDF의 포괄적인 PDF 기능으로 데이터를 획득하는 시스템에서 게임 서버 및 산업 제어 시스템에 이르는 다양한 요구사항을 충족하기 위해 확장 가능하고 다목적 응용 프로그램을 개발할 수 있습니다.

IronPDF는 무료 체험판을 제공하며, 라이선스는 $799부터 시작하여 귀하의 개발 프로젝트에 광범위한 기능을 저렴하게 제공합니다. 이 두 라이브러리를 병합함으로써 서버가 복잡한 작업을 효율적으로 처리할 수 있는 능력을 간소화하여 기능과 성능 모두를 향상시킬 수 있습니다.

자주 묻는 질문

SuperSocket C#의 용도는 무엇인가요?

SuperSocket C#은 서버 측 소켓 애플리케이션을 개발하는 데 사용됩니다. 다양한 네트워크 프로토콜을 지원하여 GPS 서버 및 산업 제어 시스템과 같은 환경에 적합합니다.

.NET 애플리케이션에서 HTML을 PDF로 변환하는 방법은 무엇입니까?

IronPDF의 RenderHtmlAsPdf 메서드를 사용하여 HTML 문자열을 PDF로 변환하고, RenderHtmlFileAsPdf를 사용하여 HTML 파일을 .NET 애플리케이션 내에서 PDF로 변환할 수 있습니다.

닷넷 프로젝트에서 SuperSocket 서버를 설정하려면 어떻게 해야 하나요?

닷넷 프로젝트에서 SuperSocket 서버를 설정하려면 SuperSocket NuGet 패키지를 설치하고, appsettings.json 파일을 사용하여 서버를 구성한 후 애플리케이션 코드 내에서 서버를 초기화해야 합니다.

IronPDF가 서버 측 애플리케이션을 어떻게 향상시킬 수 있나요?

IronPDF는 동적 PDF 생성 및 처리 기능을 제공하여 클라이언트 요청에 따라 실시간으로 PDF 문서를 생성 및 배포함으로써 서버 측 애플리케이션을 향상시킬 수 있습니다.

SuperSocket이 여러 프로토콜 리스너를 관리할 수 있나요?

네, SuperSocket은 여러 프로토콜 리스너를 관리할 수 있으며, 데이터를 수집하는 서버와 같은 애플리케이션에서 다양한 프로토콜 및 포트를 동시에 처리할 수 있도록 하는 단일 서버 인스턴스를 허용합니다.

IronPDF는 PDF 문서 처리를 위해 어떤 혜택을 제공하나요?

IronPDF는 PDF 문서의 생성, 편집, 콘텐츠 추출을 위한 포괄적인 기능을 제공합니다. 이는 고급 PDF 문서 처리 및 조작을 요구하는 애플리케이션에 이상적입니다.

SuperSocket은 동시 소켓 연결을 어떻게 처리합니까?

SuperSocket은 세션 클래스를 사용하여 연결 이벤트를 관리하여 동시 소켓 연결을 처리하고, 고부하 상태에서도 안정적인 통신과 강력한 서버 성능을 보장합니다.

SuperSocket 애플리케이션에 PDF 기능을 통합할 수 있습니까?

네, SuperSocket 애플리케이션에 IronPDF를 통합하여 동적 PDF 생성 및 편집과 같은 PDF 기능을 추가하여 애플리케이션의 기능을 향상시킬 수 있습니다.

SuperSocket의 일반적인 사용 사례는 무엇입니까?

SuperSocket의 일반적인 사용 사례에는 GPS 서버, 산업 제어 시스템, 데이터 수집 서버 및 실시간 게임 서버가 포함되며, 모두 효율적이고 안정적인 소켓 통신의 혜택을 받습니다.

SuperSocket에서 이진 데이터를 처리할 수 있는 방법은 무엇입니까?

SuperSocket은 세션 클래스를 사용하여 들어오는 이진 패키지를 처리하고 응답을 보내어 이진 수준의 데이터 처리가 필요한 애플리케이션에서 이진 데이터를 효율적으로 처리합니다.

IronPDF가 HTML에서 PDF 변환을 서버 애플리케이션에서 지원합니까?

네, IronPDF는 서버 애플리케이션에서 HTML에서 PDF로의 변환을 지원하여 HTML 콘텐츠를 고품질 PDF 문서로 원활하게 변환할 수 있습니다.

제이콥 멜러, 팀 아이언 최고기술책임자
제이콥 멜러
  지금 바로 엔지니어링 팀과 채팅하세요
최고기술책임자

제이콥 멜러는 Iron Software의 최고 기술 책임자(CTO)이자 C# PDF 기술을 개척한 선구적인 엔지니어입니다. Iron Software의 핵심 코드베이스를 최초로 개발한 그는 창립 초기부터 회사의 제품 아키텍처를 설계해 왔으며, CEO인 캐머런 리밍턴과 함께 회사를 NASA, 테슬라, 그리고 전 세계 정부 기관에 서비스를 제공하는 50명 이상의 직원을 보유한 기업으로 성장시켰습니다.

제이콥은 맨체스터 대학교에서 토목공학 학사 학위(BEng)를 최우등으로 취득했습니다(1998~2001). 1999년 런던에서 첫 소프트웨어 회사를 설립하고 2005년 첫 .NET 컴포넌트를 개발한 후, 마이크로소프트 생태계 전반에 걸쳐 복잡한 문제를 해결하는 데 전문성을 발휘해 왔습니다.

그의 대표 제품인 IronPDF 및 Iron Suite .NET 라이브러리는 전 세계적으로 3천만 건 이상의 NuGet 설치 수를 기록했으며, 그의 핵심 코드는 전 세계 개발자들이 사용하는 다양한 도구에 지속적으로 활용되고 있습니다. 25년의 실무 경험과 41년의 코딩 전문성을 바탕으로, 제이콥은 차세대 기술 리더들을 양성하는 동시에 기업 수준의 C#, Java, Python PDF 기술 혁신을 주도하는 데 주력하고 있습니다.

관련 기사

30일 무료 체험 → 모든 기능 이용 가능. 제한 없음. 카드 정보 필요 없음. 무료 체험 시작하기

아이언 서포트 팀

저희는 주 5일, 24시간 온라인으로 운영합니다.
채팅
이메일
전화해