Iron Suite for .NET

10 bibliotek .NET. Jeden kompletny pakiet dokumentów.

Odkryj Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

PORÓWNANIE

PeachPDF vs IronPDF: Przewodnik porównania technicznego

Curtis Chau

Updated: 28 czerwca 2026

Wybór odpowiedniej biblioteki PDF dla aplikacji .NET obejmuje ocenę możliwości renderowania, projektu API, głębokości funkcji i długoterminowej utrzymywalności. To techniczne porównanie analizujePeachPDFi IronPDFw aspektach najważniejszych dla profesjonalnych programistów i architektów .NET planujących przyszłe procesy generowania PDF.

Czym jest PeachPDF?

PeachPDF to stosunkowo nowa opcja w ekosystemie .NET zaprojektowana dla programistów potrzebujących konwersji HTML do PDF. Biblioteka oferuje czystą implementację .NET, wyróżniając się tym, że nie opiera się na zewnętrznych procesach. To zarządzane podejście czyniPeachPDFlekkim wyborem dla projektów szukających prostego wdrożenia na platformach, gdzie .NET jest wspierany.

Jako biblioteka open-source z licencją BSD-3-Clause,PeachPDFpozwala programistom na nieograniczony dostęp do modyfikacji i dostosowania biblioteki do konkretnych potrzeb. Jednak jej status rozwoju jest ciągły, co oznacza zarówno ekscytujące możliwości, jak i zauważalne ograniczenia. Mniejsza baza użytkowników oznacza, że wsparcie społeczności może być ograniczone, co utrudnia znalezienie obszernej dokumentacji lub szybkie uzyskanie pomocy w razie problemów.

Czym jest IronPDF?

IronPDF to uznana biblioteka .NET do obsługi plików PDF, która ma ponad 40 milionów pobrań z NuGet. Biblioteka wykorzystuje wbudowany silnik renderujący Google Chromium, aby zapewnić wysokiej jakości konwersję HTML do PDF, która dokładnie zachowuje układ i styl.IronPDFoferuje pełen zestaw funkcji, w tym podpisy cyfrowe, zgodność z formatem PDF/A, wypełnianie formularzy, wyodrębnianie tekstu oraz zaawansowane opcje bezpieczeństwa.

IronPDF obsługuje nowoczesne frameworki .NET i oferuje pełną kompatybilność z .NET 10 oraz C# 14 dla zespołów tworzących aplikacje z myślą o przyszłych terminach wdrożenia. Biblioteka obejmuje profesjonalne wsparcie z dedykowaną pomocą przy wdrożeniach Enterprise.

Porównanie podstawowej architektury

Podstawowa różnica międzyPeachPDFa IronPDFpolega na podejściu do renderowania. Zrozumienie tych wyborów architektonicznych pomaga zespołom podejmować świadome decyzje dotyczące tego, która biblioteka najlepiej odpowiada ich wymaganiom.

Aspekt	PeachPDF	IronPDF
Wdrożenie	Czysty kod zarządzany .NET	Zarządzane silnikiem Chromium
Silnik renderujący	Podstawowy parser HTML	Pełna wersja Google Chromium
Zależności zewnętrzne	None	Minimalne, oparte na platformie
Model licencji	Open Source (BSD-3-Clause)	Komercjalne
Stan rozwoju	W trakcie opracowywania	Dojrzałe, stabilne wersje
Baza użytkowników	Mała społeczność	Duża (ponad 40 mln pobrań)
Model wsparcia	Tworzone przez społeczność	Professional, dedykowane wsparcie

Czysty rdzeń .NET Core wPeachPDFzapewnia wdrożenie we wszystkich środowiskach obsługujących .NET bez zewnętrznych zależności. Może to uprościć konteneryzację i zmniejszyć złożoność wdrażania. Jednakże pojawia się kompromis w zakresie wierności renderowania — podstawowe parsowanie HTML nie może dorównać pikselowej dokładności pełnego silnika przeglądarki.

Podejście IronPDFoparte na Chromium zapewnia renderowanie zgodne z tym, co programiści widzą w Chrome DevTools. Jest to szczególnie cenne podczas konwersji złożonych aplikacji internetowych, pulpitów nawigacyjnych lub stylizowanych raportów, w których CSS Grid, Flexbox i wykonanie kodu JavaScript wpływają na ostateczny wynik.

Konwersja HTML do PDF

Konwersja treści HTML do formatu PDF stanowi najczęstszy przypadek użycia obu bibliotek. Projekt API i możliwości renderowania znacznie różnią się w obu rozwiązaniach.

WdrożeniePeachPDFHTML-to-PDF

PeachPDF wykorzystuje wzorzec oparty na konwerterze, w którym programiści tworzą HtmlToPdfConverter i wywołują metodę Convert:

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("output.pdf", pdf);
    }
}

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("output.pdf", pdf);
    }
}

Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = converter.Convert(html)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Class

Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = converter.Convert(html)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Class

Konwerter zwraca tablicę bajtów, co wymaga ręcznych operacji na plikach w celu zapisania wyniku. Ten wzorzec sprawdza się w przypadku prostych konwersji, ale wymaga dodatkowego kodu do typowych operacji, takich jak zapisywanie bezpośrednio na dysk.

Wdrożenie IronPDFHTML-to-PDF

IronPDF wykorzystuje klasę ChromePdfRenderer, która zapewnia płynny API z wbudowanymi operacjami zapisu:

using IronPdf;

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

using IronPdf;

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

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

Imports IronPdf

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

Metoda RenderHtmlAsPdf zwraca obiekt PdfDocument, który kapsułkuje wyrenderowaną zawartość i zapewnia metody do zapisywania, manipulacji i dostępu do metadanych. To podejście obiektowe w naturalny sposób integruje się z kolejnymi operacjami, takimi jak dodawanie znaków wodnych, scałanie dokumentów lub stosowanie ustawień zabezpieczeń.

Silnik Chromium firmy IronPDFobsługuje HTML5, CSS3 i JavaScript podczas konwersji, umożliwiając dokładne renderowanie nowoczesnych treści internetowych, w tym animacji, responsywnych układów i elementów generowanych dynamicznie.

Konwersja adresów URL do formatu PDF

Konwersja aktywnych stron internetowych do formatu PDF wymaga pobierania zdalnych treści i obsługi wykonywania kodu JavaScript. Te dwie biblioteki radzą sobie z tym scenariuszem w różny sposób.

Konwersja adresów URL w PeachPDF

PeachPDF umożliwia konwersję adresów URL za pomocą klasy konwertera:

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        var pdf = converter.ConvertUrl(url);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        var pdf = converter.ConvertUrl(url);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}

Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim url = "https://www.example.com"
        Dim pdf = converter.ConvertUrl(url)
        File.WriteAllBytes("webpage.pdf", pdf)
    End Sub
End Class

Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim url = "https://www.example.com"
        Dim pdf = converter.ConvertUrl(url)
        File.WriteAllBytes("webpage.pdf", pdf)
    End Sub
End Class

Implementacja obsługuje podstawowe pobieranie adresów URL, ale może mieć trudności ze stronami, które w dużym stopniu opierają się na JavaScript do renderowania treści lub które wymagają określonych warunków oczekiwania przed pełnym załadowaniem strony.

Konwersja adresów URL w IronPDF

Konwersja adresów URL do formatu PDF w IronPDFwykorzystuje pełne środowisko uruchomieniowe JavaScript silnika Chromium:

using IronPdf;

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

using IronPdf;

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

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

Imports IronPdf

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

W przypadku stron z treścią dynamicznąIronPDFoferuje opcje renderowania umożliwiające kontrolowanie czasu wykonywania kodu JavaScript:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(3000);

var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("webpage.pdf");

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(3000);

var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("webpage.pdf");

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.JavaScript(3000)

Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
pdf.SaveAs("webpage.pdf")

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.JavaScript(3000)

Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
pdf.SaveAs("webpage.pdf")

Metoda WaitFor.JavaScript pozwala określić opóźnienie, aby zapewnić zakończenie renderowania po stronie klienta przed rozpoczęciem generowania PDF. Ma to kluczowe znaczenie w przypadku aplikacji jednostronicowych lub treści ładowanych asynchronicznie.

Nagłówki i stopki

Dodanie nagłówków i stopek do dokumentów PDF poprawia profesjonalny wygląd prezentacji i umożliwia numerację stron, umieszczenie logo oraz wyświetlanie metadanych dokumentu. Podejścia do implementacji różnią się znacznie w zależności od biblioteki.

Nagłówki i stopki PeachPDF

PeachPDF udostępnia w konwerterze właściwości nagłówków i stopek oparte na ciągach znaków:

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        converter.Header = "<div style='text-align:center'>My Header</div>";
        converter.Footer = "<div style='text-align:center'>Page {page}</div>";
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("document.pdf", pdf);
    }
}

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        converter.Header = "<div style='text-align:center'>My Header</div>";
        converter.Footer = "<div style='text-align:center'>Page {page}</div>";
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("document.pdf", pdf);
    }
}

Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        converter.Header = "<div style='text-align:center'>My Header</div>"
        converter.Footer = "<div style='text-align:center'>Page {page}</div>"
        Dim html = "<html><body><h1>Document Content</h1></body></html>"
        Dim pdf = converter.Convert(html)
        File.WriteAllBytes("document.pdf", pdf)
    End Sub
End Class

Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        converter.Header = "<div style='text-align:center'>My Header</div>"
        converter.Footer = "<div style='text-align:center'>Page {page}</div>"
        Dim html = "<html><body><h1>Document Content</h1></body></html>"
        Dim pdf = converter.Convert(html)
        File.WriteAllBytes("document.pdf", pdf)
    End Sub
End Class

Symbol zastępczy {page} zapewnia podstawowe numerowanie stron. Implementacja obsługuje proste scenariusze, ale brakuje jej zaawansowanych opcji dostosowywania dla złożonych układów nagłówków lub formatowania warunkowego.

Nagłówki i stopki IronPDF

IronPDF oferuje nagłówki i stopki oparte na HTML z pełną obsługą CSS i wieloma polami scałania:

using IronPdf;
using IronPdf.Rendering;

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

using IronPdf;
using IronPdf.Rendering;

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

Class Program
    Shared Sub Main()
        Dim renderer = 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 = "<html><body><h1>Document Content</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("document.pdf")
    End Sub
End Class

Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer = 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 = "<html><body><h1>Document Content</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("document.pdf")
    End Sub
End Class

IronPDF obsługuje dodatkowe pola scalania, w tym {total-pages}, {url}, {date}, {time}, {html-title} i {pdf-title}. Klasa HtmlHeaderFooter akceptuje również właściwość MaxHeight do kontrolowania wymiarów nagłówka/stopki:

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"<div style='text-align:center; font-size:10pt;'>Company Report</div>",
    MaxHeight = 30
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"<div style='text-align:center; font-size:9pt;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"<div style='text-align:center; font-size:10pt;'>Company Report</div>",
    MaxHeight = 30
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"<div style='text-align:center; font-size:9pt;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};

Imports System

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:center; font-size:10pt;'>Company Report</div>",
    .MaxHeight = 30
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:center; font-size:9pt;'>Page {page} of {total-pages}</div>",
    .MaxHeight = 25
}

Imports System

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:center; font-size:10pt;'>Company Report</div>",
    .MaxHeight = 30
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:center; font-size:9pt;'>Page {page} of {total-pages}</div>",
    .MaxHeight = 25
}

Tabela porównawcza funkcji

Oprócz podstawowej konwersji biblioteki PDF muszą obsługiwać manipulację dokumentami, zabezpieczenia i zaawansowane formatowanie. To porównanie podkreśla różnice w funkcjonalnościach obu bibliotek w oparciu o ich udokumentowane możliwości.

Funkcja	PeachPDF	IronPDF
HTML do PDF	Podstawowe	Pełny Chromium
URL do pliku PDF	Ograniczone	Obsługiwane
CSS Grid/Flexbox	Nie	Tak
Wykonanie kodu JavaScript	Ograniczone	Pełna wersja ES2024
Łączenie plików PDF	Tak	Tak
Podział plików PDF	Ograniczone	Tak
Znaki wodne	Ograniczone	Pełny kod HTML
Nagłówki/stopki	Podstawowe	Pełny kod HTML
Podpisy cyfrowe	Nie	Tak
Zgodność z PDF/A	Nie	Tak
Wypełnianie formularzy	Ograniczone	Tak
Ekstrakcja tekstu	Podstawowe	Tak
Wyodrębnianie obrazów	Nie	Tak
Ochrona hasłem	Ograniczone	Tak
Obsługa asynchroniczna	Ograniczone	Tak
Wielopłatformowe	Nieznane	Windows, Linux, macOS, Docker

Podpisy cyfrowe i bezpieczeństwo

Aplikacje Enterprise często wymagają podpisów kryptograficznych i zabezpieczeń dokumentów. Te możliwości odróżniają dojrzałe biblioteki PDF od podstawowych narzędzi do konwersji.

PeachPDF nie obsługuje obecnie podpisów cyfrowych, co ogranicza jego zastosowanie w procesach obiegu dokumentów wymagających uwierzytelnienia lub zgodności z przepisami prawnymi.

IronPDF zapewnia kompleksowe możliwości w zakresie podpisów cyfrowych przy użyciu certyfikatów X.509:

using IronPdf;
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;
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
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")

Imports IronPdf
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")

W celu ochrony hasłem i kontroli dostępu IronPDFudostępnia szczegółowe ustawienia zabezpieczeń:

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

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

Operacje na plikach PDF

Praca z istniejącymi plikami PDF wymaga możliwości ich ładowania, modyfikowania i scałania. Obie biblioteki obsługują podstawowe operacje, ale zakres ich funkcjonalności jest różny.

Wczytywanie i modyfikowanie plików PDF

Podejście PeachPDF:

using PeachPDF;

var document = PdfReader.LoadFromFile("input.pdf");
document.AddPage();
document.Save("modified.pdf");

using PeachPDF;

var document = PdfReader.LoadFromFile("input.pdf");
document.AddPage();
document.Save("modified.pdf");

Imports PeachPDF

Dim document = PdfReader.LoadFromFile("input.pdf")
document.AddPage()
document.Save("modified.pdf")

Imports PeachPDF

Dim document = PdfReader.LoadFromFile("input.pdf")
document.AddPage()
document.Save("modified.pdf")

Podejście IronPDF:

using IronPdf;

var pdf = PdfDocument.FromFile("input.pdf");

var renderer = new ChromePdfRenderer();
var newPage = renderer.RenderHtmlAsPdf("<h1>New Page</h1>");
pdf.AppendPdf(newPage);

pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>");

pdf.SaveAs("modified.pdf");

using IronPdf;

var pdf = PdfDocument.FromFile("input.pdf");

var renderer = new ChromePdfRenderer();
var newPage = renderer.RenderHtmlAsPdf("<h1>New Page</h1>");
pdf.AppendPdf(newPage);

pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>");

pdf.SaveAs("modified.pdf");

Imports IronPdf

Dim pdf = PdfDocument.FromFile("input.pdf")

Dim renderer = New ChromePdfRenderer()
Dim newPage = renderer.RenderHtmlAsPdf("<h1>New Page</h1>")
pdf.AppendPdf(newPage)

pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>")

pdf.SaveAs("modified.pdf")

Imports IronPdf

Dim pdf = PdfDocument.FromFile("input.pdf")

Dim renderer = New ChromePdfRenderer()
Dim newPage = renderer.RenderHtmlAsPdf("<h1>New Page</h1>")
pdf.AppendPdf(newPage)

pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>")

pdf.SaveAs("modified.pdf")

IronPDF umożliwia dodawanie treści renderowanych w HTML jako nowych stron oraz stosowanie znaków wodnych przy użyciu pełnego formatowania HTML/CSS.

Łączenie wielu plików PDF

Scałanie PeachPDF:

using PeachPDF;

var doc1 = PdfReader.LoadFromFile("doc1.pdf");
var doc2 = PdfReader.LoadFromFile("doc2.pdf");
doc1.MergeWith(doc2);
doc1.Save("merged.pdf");

using PeachPDF;

var doc1 = PdfReader.LoadFromFile("doc1.pdf");
var doc2 = PdfReader.LoadFromFile("doc2.pdf");
doc1.MergeWith(doc2);
doc1.Save("merged.pdf");

Imports PeachPDF

Dim doc1 = PdfReader.LoadFromFile("doc1.pdf")
Dim doc2 = PdfReader.LoadFromFile("doc2.pdf")
doc1.MergeWith(doc2)
doc1.Save("merged.pdf")

Imports PeachPDF

Dim doc1 = PdfReader.LoadFromFile("doc1.pdf")
Dim doc2 = PdfReader.LoadFromFile("doc2.pdf")
doc1.MergeWith(doc2)
doc1.Save("merged.pdf")

Scałanie IronPDF:

using IronPdf;

var pdf1 = PdfDocument.FromFile("doc1.pdf");
var pdf2 = PdfDocument.FromFile("doc2.pdf");

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

using IronPdf;

var pdf1 = PdfDocument.FromFile("doc1.pdf");
var pdf2 = PdfDocument.FromFile("doc2.pdf");

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

Imports IronPdf

Dim pdf1 = PdfDocument.FromFile("doc1.pdf")
Dim pdf2 = PdfDocument.FromFile("doc2.pdf")

Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

Imports IronPdf

Dim pdf1 = PdfDocument.FromFile("doc1.pdf")
Dim pdf2 = PdfDocument.FromFile("doc2.pdf")

Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

Statyczna metoda Merge w IronPDFakceptuje wiele dokumentów i tworzy nowy, połączony PDF bez modyfikowania dokumentów źródłowych. Biblioteka obsługuje również dzielenie plików PDF i wyodrębnianie określonych zakresów stron.

Operacje asynchroniczne

Nowoczesne aplikacje .NET korzystają z wzorców async/await w operacjach związanych z wejściem/wyjściem. Ta funkcja wpływa na wydajność aplikacji internetowych i usług obsługujących równoczesne żądania generowania plików PDF.

PeachPDF zapewnia przede wszystkim operacje synchroniczne:

var document = PdfDocument.Create();
document.AddHtmlContent(html);

var document = PdfDocument.Create();
document.AddHtmlContent(html);

Dim document = PdfDocument.Create()
document.AddHtmlContent(html)

Dim document = PdfDocument.Create()
document.AddHtmlContent(html)

IronPDF obsługuje asynchroniczne generowanie plików PDF:

using IronPdf;

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

using IronPdf;

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

Imports IronPdf

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

Imports IronPdf

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

Obsługa asynchroniczna umożliwia wydajną obsługę wielu równoczesnych żądań generowania plików PDF bez blokowania wątków, poprawiając przepustowość w aplikacjach ASP.NET Core i usługach działających w tle.

Mapowanie API dla migracji PeachPDF

Zespoły rozważające przejście zPeachPDFna IronPDFmogą skorzystać z poniższego zestawienia równoważnych operacji:

PeachPDF	IronPDF
`PdfDocument.Create()`	`new ChromePdfRenderer()`
`document.AddHtmlContent(html)`	`renderer.RenderHtmlAsPdf(html)`
`document.Save(path)`	`pdf.SaveAs(path)`
`document.ToByteArray()`	`pdf.BinaryData`
`PdfReader.LoadFromFile(path)`	`PdfDocument.FromFile(path)`
`document.AddPage()`	`pdf.AddPdfPages(newPdf)`
`document.SetMetadata()`	`pdf.MetaData`
`document.MergeWith(other)`	`PdfDocument.Merge(pdfs)`

Główna różnica w architekturze polega na oddzieleniu przez IronPDFrenderera (który konwertuje zawartość) od dokumentu (który reprezentuje plik PDF). Takie rozdzielenie pozwala na jednokrotne skonfigurowanie opcji renderowania i ponowne wykorzystanie ich w wielu konwersjach.

Kiedy zespoły rozważają migrację do PeachPDF

Kilka czynników skłania zespoły programistów do rozważenia alternatyw dla PeachPDF:

Ograniczenia renderowania stają się widoczne, gdy aplikacje muszą dokładnie odtworzyć złożone układy CSS, responsywne projekty lub treści oparte na JavaScript. Podstawowa analiza HTML wPeachPDFnie dorównuje dokładności silnika przeglądarki w przypadku zaawansowanych treści internetowych.

Wraz z rozwojem aplikacji rozszerzają się wymagania dotyczące funkcji. Podpisy cyfrowe, zgodność z formatem PDF/A do archiwizacji, wypełnianie formularzy i zaawansowane zabezpieczenia to funkcje, których obecnie brakuje w PeachPDF. Tworzenie obejść dla brakujących funkcji zwiększa dług techniczny i obciążenie związane z utrzymaniem.

Kwestie związane ze wsparciem technicznym mają wpływ na wdrożenia produkcyjne. Wsparcie społecznościowe dla nowszej biblioteki może nie zapewniać czasu reakcji lub wiedzy specjalistycznej wymaganej w przypadku aplikacji o znaczeniu krytycznym. Profesjonalne wsparcie w ramach umów SLA zapewnia przewidywalność operacji Enterprise.

Szczegółowość dokumentacji wpływa na wydajność programistów. Obszerne samouczki, przykłady kodu i Dokumentacja API przyspieszają wdrażanie i skracają czas rozwiązywania problemów. Dokumentacja i samouczkiIronPDFzapewniają kompleksowe omówienie typowych scenariuszy.

Zalety i kompromisy

Atuty PeachPDF

Czysta implementacja .NET bez zewnętrznych zależności
Licencja open source bez kosztów dla programistów
Proste API do podstawowej konwersji HTML na PDF
Niewielkie obciążenie podczas wdrażania

Ograniczenia PeachPDF

Podstawowe renderowanie HTML bez pełnej obsługi CSS3
Ograniczona zdolność wykonywania kodu JavaScript
Brak funkcji podpisu cyfrowego
Mniejsze zasoby społecznościowe i dokumentacyjne
Niepewna ścieżka rozwoju jako nowsza biblioteka

Atuty IronPDF

Pełny silnik renderujący Chromium zapewniający idealną jakość obrazu
Kompleksowy zestaw funkcji, w tym podpisy, formularze i zabezpieczenia
Obszerna dokumentacja z przykładami kodu
Profesjonalne wsparcie z dedykowaną pomocą
Aktywny rozwój z regularnymi aktualizacjami
Wdrażanie wielopłatformowe, w tym w środowiskach Docker i chmury

Uwagi dotyczące IronPDF

Komercyjny model licencjonowania wymaga przydzielenia środków budżetowych
Zależność od Chromium zwiększa rozmiar wdrożenia
Wymaga konfiguracji klucza licencyjnego do użytku produkcyjnego

Wnioski

PeachPDF oferuje lekkie rozwiązanie typu open source dla zespołów o podstawowych wymaganiach dotyczących konwersji HTML do PDF i ograniczonym budżecie. Czysta implementacja .NET upraszcza wdrażanie, a liberalna licencja eliminuje bariery kosztowe.

IronPDF zapewnia dokładność renderowania, bogactwo funkcji i profesjonalne wsparcie, których zazwyczaj wymagają aplikacje produkcyjne. Silnik Chromium gwarantuje niezawodną konwersję złożonych treści internetowych, a kompleksowe funkcje bezpieczeństwa i edycji wspierają przepływ dokumentów w przedsiębiorstwie.

Dla zespołów planujących wdrożenie funkcji generowania plików PDF w aplikacjach .NET z myślą o przyszłym wdrożeniu, dojrzała architektura IronPDF, bogaty zestaw funkcji i aktywna konserwacja sprawiają, że jest to doskonały wybór dla długoterminowych inwestycji w rozwój. Kompatybilność biblioteki z platformą .NET 10 i nowoczesnymi funkcjami języka C# gwarantuje, że aplikacje pozostaną aktualne w miarę ewolucji ekosystemu .NET.

Aby uzyskać dodatkowe wskazówki dotyczące wdrażania, zapoznaj się z samouczkiem IronPDF dotyczącym konwersji HTML do PDF oraz przykładami kodu obejmującymi typowe scenariusze generowania plików PDF.

Zwróć uwagę: PeachPDF jest zarejestrowanym znakiem towarowym swojego właściciela. Ta strona nie jest powiązana z, popierana przez ani sponsorowana przez PeachPDF. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.