Jak przeprowadzić migrację z PeachPDF do IronPDF w języku C#

Zrozumienie PeachPDF

PeachPDF to stosunkowo nowy gracz w ekosystemie .NET, stworzony dla programistów, którzy potrzebują konwertować HTML na PDF. Jako biblioteka,PeachPDFzapewnia czystą implementację .NET, wyróżniając się tym, że nie opiera się na procesach zewnętrznych, co gwarantuje płynną integrację na platformach obsługujących .NET. Ta cecha sprawia, żePeachPDFjest atrakcyjnym wyborem dla projektów poszukujących lekkiego, zarządzanego rozwiązania bibliotecznego.

Pomimo swojego potencjału,PeachPDFjest nadal w fazie rozwoju, co wskazuje zarówno na ekscytujące możliwości, jak i na istotne ograniczenia.PeachPDFpozostaje atrakcyjny dzięki czystemu rdzeniu .NET Core, który zapewnia proste wdrożenie w różnych środowiskach. Jednak oznacza to również ograniczone zastosowanie, mniejszą bazę użytkowników i wsparcie oparte na społeczności.

Ograniczenia PeachPDF

PeachPDF to biblioteka .NET utrzymywana przez jednego opiekuna, w wersji przed 1.0 (najnowsza 0.7.26, październik 2025) wydana na licencjiBSD-3-Clauseprzez jhaygood86. Brakuje jej dojrzalosci, funkcji i wsparcia w porownaniu do ugruntowanych rozwiazan. Główne powody migracji:

1. Zestaw funkcji przed wersja 1.0:PeachPDFnie ma wbudowanych podpisow cyfrowych, zgodnosci z PDF/A, OCR, wypelniania formularzy ani API naglowkow/stopek na poziomie strony.

2. Bez silnika JavaScript:PeachPDFto renderer układu zbudowany na PeachPDF.PdfSharpCore, a nie przeglądarka; skrypty i skomplikowane uklady Grid/Flexbox nie sa wykonywane.

3. Tylko net8.0: pakiet celuje w net8.0; starsze projekty .NET Framework / .NET 6 musza zaktualizowac lub wybrac inna biblioteke.

4. Mala Spolecznosc: jeden opiekun GitHub, ograniczona dokumentacja, ograniczone przyklady.

5. Brak wsparcia dla Enterprise: brak komercyjnego wsparcia ani opcji SLA.

PorównaniePeachPDFi IronPDF

IronPDF wyróżnia się szerszą funkcjonalnością, obsługując nie tylko konwersję HTML do PDF, ale także OCR, znakowanie wodne i inne zaawansowane funkcje. Jego profesjonalna struktura wsparcia oferuje szybkie sciezki rozwiazywania problemow napotkanych przez deweloperow.

Dla zespolow przyjmujacych nowoczesny .NET,IronPDF zapewnia kompleksowe funkcje i aktywne utrzymywanie, aby wspierac dlugotrwala stabilnosc w aktualnych wersjach .NET.

Wymagania wstępne

1. Środowisko .NET: .NET Framework 4.6.2+ lub .NET Core 3.1+ / .NET 5/6/7/8/9+
2. Dostęp do NuGet: Możliwość instalowania pakietów NuGet
3. Licencja IronPDF: Uzyskaj klucz licencyjny na stronie ironpdf.com

Zmiany w pakiecie NuGet

# Remove PeachPDF
dotnet remove package PeachPDF

# Install IronPDF
dotnet add package IronPdf

# Remove PeachPDF
dotnet remove package PeachPDF

# Install IronPDF
dotnet add package IronPdf

Konfiguracja licencji

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Zidentyfikuj zastosowanie PeachPDF

# AuditPeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "PdfGenerator\|PdfGenerateConfig\|GeneratePdf" --include="*.cs" .

# AuditPeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "PdfGenerator\|PdfGenerateConfig\|GeneratePdf" --include="*.cs" .

Zmiany w przestrzeni nazw

// Before: PeachPDF
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before: PeachPDF
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO
Imports System.Threading.Tasks

Mapowania podstawowych interfejsów API

Przykład 1: Konwersja ciągu znaków HTML do formatu PDF

Przed (PeachPDF):

using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            PageOrientation = PageOrientation.Portrait
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("output.pdf");
        document.Save(stream);
    }
}

using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            PageOrientation = PageOrientation.Portrait
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("output.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.PdfSharpCore
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim config As New PdfGenerateConfig With {
            .PageSize = PageSize.Letter,
            .PageOrientation = PageOrientation.Portrait
        }

        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(html, config)

        Using stream As FileStream = File.Create("output.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Ten przykład pokazuje fundamentalną różnicę między dwiema bibliotekami.PeachPDFoddziela PdfGenerator (silnik) od PdfGenerateConfig (ustawienia), udostępnia asynchroniczną metodę GeneratePdf, a zwraca dokument, którego metoda Save zapisuje do Stream.IronPDF używa ChromePdfRenderer z RenderHtmlAsPdf(), co zwraca obiekt PdfDocument z wbudowaną metodą SaveAs().

Praktyczna zaleta podejścia IronPDF: obiekt PdfDocument można dalej manipulować (dodawanie znaków wodnych, scalanie, ustawienia bezpieczeństwa) przed zapisaniem, a SaveAs przyjmuje ścieżkę pliku bez pośredniego FileStream. Zobacz dokumentację HTML do PDF dla dalszych przykładów.

Przykład 2: Konwersja adresów URL do formatu PDF

Przed (PeachPDF):

//PeachPDFhas no ConvertUrl-style helper; URL fetching is wired via
// HttpClientNetworkAdapter and passing null HTML so the engine fetches the page.
using PeachPDF;
using PeachPDF.Network;
using PeachPDF.PdfSharpCore;
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var http = new HttpClient();

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            NetworkAdapter = new HttpClientNetworkAdapter(http, new Uri("https://www.example.com"))
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(null, config);

        using var stream = File.Create("webpage.pdf");
        document.Save(stream);
    }
}

//PeachPDFhas no ConvertUrl-style helper; URL fetching is wired via
// HttpClientNetworkAdapter and passing null HTML so the engine fetches the page.
using PeachPDF;
using PeachPDF.Network;
using PeachPDF.PdfSharpCore;
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var http = new HttpClient();

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            NetworkAdapter = new HttpClientNetworkAdapter(http, new Uri("https://www.example.com"))
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(null, config);

        using var stream = File.Create("webpage.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.Network
Imports PeachPDF.PdfSharpCore
Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim http As New HttpClient()

        Dim config As New PdfGenerateConfig With {
            .PageSize = PageSize.Letter,
            .NetworkAdapter = New HttpClientNetworkAdapter(http, New Uri("https://www.example.com"))
        }

        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(Nothing, config)

        Using stream As FileStream = File.Create("webpage.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim url = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

PeachPDF nie ma pierwszorzędnej pomocy przy konwersji URL do PDF; ustaw NetworkAdapter w konfiguracji na HttpClientNetworkAdapter i przekazuj null HTML, aby silnik pobierał stronę.IronPDF eksponuje bezpośrednio RenderUrlAsPdf(url). PonieważPeachPDFnie wykonuje JavaScriptu, aplikacje jednostronicowe i dynamiczne treści zazwyczaj nie będą renderowane poprawnie przez ścieżkę przez adapter sieciowy; silnik Chromium w IronPDF obsługuje nowoczesny CSS i JavaScript. Dowiedz się więcej z naszych samouczków.

Przykład 3: Dodawanie nagłówków i stopek

Przed (PeachPDF):

//PeachPDFv0.7.x has no header/footer API. The closest approach is
// to embed the header/footer markup directly inside the source HTML
// using CSS positioning.
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = @"
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>";

        var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("document.pdf");
        document.Save(stream);
    }
}

//PeachPDFv0.7.x has no header/footer API. The closest approach is
// to embed the header/footer markup directly inside the source HTML
// using CSS positioning.
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = @"
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>";

        var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("document.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.PdfSharpCore
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>"

        Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(html, config)

        Using stream As FileStream = File.Create("document.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>My Header</div>" };
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>Page {page}</div>" };
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>My Header</div>" };
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>Page {page}</div>" };
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {.HtmlFragment = "<div style='text-align:center'>My Header</div>"}
        renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {.HtmlFragment = "<div style='text-align:center'>Page {page}</div>"}
        Dim html As String = "<html><body><h1>Document Content</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("document.pdf")
    End Sub
End Module

Ten przykład pokazuje kluczową różnicę architektoniczną.PeachPDFnie eksponuje API nagłówka/stopki na PdfGenerator ani PdfGenerateConfig, więc chrom strony musi być umieszczony w źródle HTML za pomocą pozycjonowania CSS.IronPDF używa obiektów HtmlHeaderFooter przypisanych do RenderingOptions.HtmlHeader i RenderingOptions.HtmlFooter, oddzielając chrom strony od treści dokumentu.

Podejście IronPDF również eksponuje właściwości jak MaxHeight dla kontrolowania rozmiaru nagłówka/stopki i obsługuje zastępniki {page} i {total-pages} dla numerowania stron.

Zwróć uwagę na dodatkową przestrzeń nazw wymaganą dla IronPDF: using IronPdf.Rendering; jest potrzebna dla klasy HtmlHeaderFooter.

Zmiana klasy Generator/Renderer

PeachPDF używa pary PdfGenerator + PdfGenerateConfig;IronPDF używa pojedynczego ChromePdfRenderer:

// PeachPDF
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();

// IronPDF
var renderer = new ChromePdfRenderer();

// PeachPDF
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();

// IronPDF
var renderer = new ChromePdfRenderer();

' PeachPDF
Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
Dim generator As New PdfGenerator()

' IronPDF
Dim renderer As New ChromePdfRenderer()

Asynchroniczne kontra synchroniczne i typ zwracany

Asynchroniczna tylko metoda GeneratePdfPeachPDFzwraca dokument, którego metoda Save przyjmuje Stream. Metoda RenderHtmlAsPdfIronPDF jest synchroniczna (dostępna jest również asynchroniczna wersja RenderHtmlAsPdfAsync) i zwraca PdfDocument:

// PeachPDF: async, save to a Stream
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create("output.pdf");
document.Save(fs);

// IronPDF: synchronous PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;

// PeachPDF: async, save to a Stream
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create("output.pdf");
document.Save(fs);

// IronPDF: synchronous PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;

Imports System.IO

' PeachPDF: async, save to a Stream
Dim document = Await generator.GeneratePdf(html, config)
Using fs As FileStream = File.Create("output.pdf")
    document.Save(fs)
End Using

' IronPDF: synchronous PdfDocument object
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
' Or get bytes: Dim bytes As Byte() = pdf.BinaryData

Zmiana właściwości nagłówka/stopki

// PeachPDF: no header/footer API -- embed in source HTML
// (e.g. via CSS position:fixed)

// IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div>Header</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div>Footer</div>"
};

// PeachPDF: no header/footer API -- embed in source HTML
// (e.g. via CSS position:fixed)

// IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div>Header</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div>Footer</div>"
};

' PeachPDF: no header/footer API -- embed in source HTML
' (e.g. via CSS position:fixed)

' IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div>Header</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div>Footer</div>"
}

Zmiany nazw metod

Łączenie plików PDF

var pdf1 = PdfDocument.FromFile("doc1.pdf");
var pdf2 = PdfDocument.FromFile("doc2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

var pdf1 = PdfDocument.FromFile("doc1.pdf");
var pdf2 = PdfDocument.FromFile("doc2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

CONVERTER NOT RUNNING

Znaki wodne w HTML

var pdf = PdfDocument.FromFile("document.pdf");
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>");
pdf.SaveAs("watermarked.pdf");

var pdf = PdfDocument.FromFile("document.pdf");
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>");
pdf.SaveAs("watermarked.pdf");

Dim pdf = PdfDocument.FromFile("document.pdf")
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>")
pdf.SaveAs("watermarked.pdf")

Ochrona hasłem

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;

pdf.SaveAs("protected.pdf");

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;

pdf.SaveAs("protected.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>")

pdf.SecuritySettings.OwnerPassword = "owner123"
pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint

pdf.SaveAs("protected.pdf")

Podpisy cyfrowe

using IronPdf.Signing;

var pdf = PdfDocument.FromFile("document.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Document Approval",
    SigningLocation = "New York"
};
pdf.Sign(signature);
pdf.SaveAs("signed.pdf");

using IronPdf.Signing;

var pdf = PdfDocument.FromFile("document.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Document Approval",
    SigningLocation = "New York"
};
pdf.Sign(signature);
pdf.SaveAs("signed.pdf");

Imports IronPdf.Signing

Dim pdf = PdfDocument.FromFile("document.pdf")
Dim signature = New PdfSignature("certificate.pfx", "password") With {
    .SigningReason = "Document Approval",
    .SigningLocation = "New York"
}
pdf.Sign(signature)
pdf.SaveAs("signed.pdf")

Operacje asynchroniczne

var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>");
pdf.SaveAs("async_output.pdf");

var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>");
pdf.SaveAs("async_output.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>")
pdf.SaveAs("async_output.pdf")

Problem 1: Różne wzorce API

Problem:PeachPDFoddziela PdfGenerator (silnik) od PdfGenerateConfig (ustawienia) i jest asynchroniczny;IronPDF używa jednego ChromePdfRenderer, który zwraca PdfDocument synchronicznie.

Rozwiązanie:

//PeachPDFpattern (async, stream-out)
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create(path);
document.Save(fs);

//IronPDF pattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);

//PeachPDFpattern (async, stream-out)
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create(path);
document.Save(fs);

//IronPDF pattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);

Imports System.IO

' PeachPDFpattern (async, stream-out)
Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
Dim generator As New PdfGenerator()
Dim document = Await generator.GeneratePdf(html, config)
Using fs As FileStream = File.Create(path)
    document.Save(fs)
End Using

' IronPDF pattern
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(path)

Problematyka 2: Zapis celuje do strumienia, nie do ścieżki

Problem: Metoda document.Save(stream)PeachPDFprzyjmuje tylko Stream; Metoda pdf.SaveAs(path)IronPDF przyjmuje ciągę reprezentującą ścieżkę.

Rozwiązanie: Użyj bezpośrednio pdf.SaveAs("file.pdf") w IronPDF zamiast otwierania FileStream.

Problematyka 3: Brak operacji na istniejących PDF-ach

Problem:PeachPDFjest wyłącznie HTML-do-PDF; nie można wczytywać, scalać, dzielić ani edytować istniejących PDF-ów.

Rozwiązanie: Zamień te operacje na PdfDocument.FromFile, PdfDocument.Merge i pdf.AppendPdfIronPDF po migracji.

Przed migracją

• Sprawdź, jakPeachPDFjest używany w kodzie
• Dokumentowanie konfiguracji niestandardowych
• Zwróć uwagę na wszystkie implementacje nagłówków/stopek
• Uzyskaj klucz licencyjny IronPDF ze strony ironpdf.com
• Najpierw przetestuj z Licencją Trial IronPDF

Zmiany w pakiecie

• Usuń pakiet NuGet PeachPDF
• Zainstaluj pakiet NuGet IronPdf: dotnet add package IronPdf

Zmiany w kodzie

• Zaktualizuj importy przestrzeni nazw (using PeachPDF; → using IronPdf;)
• Dodaj using IronPdf.Rendering; dla funkcji nagłówka/stopki
• Zamień PdfGenerator + PdfGenerateConfig na ChromePdfRenderer
• Zamień await generator.GeneratePdf(html, config) na renderer.RenderHtmlAsPdf(html) (lub RenderHtmlAsPdfAsync, aby pozostać asynchroniczny)
• Zamień HttpClientNetworkAdapter + GeneratePdf(null, config) na renderer.RenderUrlAsPdf(url)
• Zamień document.Save(stream) na pdf.SaveAs(path)
• Zamień nagłówki/stopki osadzone w HTML na obiekty HtmlFooter
• Dodaj inicjalizację licencji podczas uruchamiania aplikacji

Po migracji

• Sprawdź jakość renderowania HTML
• Sprawdź, czy wynik w formacie PDF jest zgodny z oczekiwaniami
• Sprawdź renderowanie nagłówków/stopek z numerami stron
• W razie potrzeby dodaj nowe funkcje (zabezpieczenia, znaki wodne, scałanie)