Nie znalazłeś tego, czego szukałeś?
Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Porównania produktów
  4. EVOPDF
PORóWNANIA PRODUKTóW

iTextSharp C# HTML do PDF Alternatywa dla .NET Core

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

Przy tworzeniu nowoczesnych aplikacji .NET, które wymagają funkcji PDF, wybór odpowiedniej biblioteki może znacznie wpłynąć na szybkość rozwoju, wydajność aplikacji i koszty utrzymania w długim okresie. IronPDF i EvoPdf reprezentują dwa różne podejścia do generowania i manipulacji PDF w ekosystemie .NET, z unikalnymi mocnymi stronami, które odpowiadają różnym scenariuszom rozwoju.

To kompleksowe porównanie bada obie biblioteki w kluczowych wymiarach, w tym dokładność renderowania, projektowanie API, wskaźniki wydajności, kompatybilność platform i całkowite koszty posiadania. Niezależnie od tego, czy tworzysz system przetwarzania dokumentów o dużej wydajności, implementujesz podpisy cyfrowe dla zgodności, czy po prostu konwertujesz raporty HTML na PDF, zrozumienie tych różnic pomoże podjąć świadomą decyzję, która będzie zgodna z Twoimi wymaganiami technicznymi i ograniczeniami budżetowymi.

Jak porównują się IronPDF i EvoPdf na pierwszy rzut oka?

Przed zanurzeniem się w szczegółowej analizie, oto przegląd tego, jak te biblioteki wypadają w kluczowych kategoriach, które są najważniejsze dla deweloperów .NET:

Przegląd porównania produktów
Porównanie IronPDF i EvoPdf dla generowania PDF w .NET
Kategoria Funkcja/Aspekt IronPDF EvoPdf Kluczowa zaleta
Podstawowa architektura Filozofia projektowania Prostota przede wszystkim, intuicyjne API Funkcje bogate, tradycyjne podejście do PDF IronPDF: Szybsze tworzenie
Złożoność API Proste metody jak RenderHtmlAsPdf() Podejście wieloklasowe z większą ilością ustawień IronPDF: Prostsza powierzchnia API
Krzywa uczenia się Minimalna wymagana konfiguracja Zaangażowana większa konfiguracja IronPDF: Szybsze przyswajanie
Obsługa platform Wielopłatformowe Natwne wsparcie, bez dodatkowej konfiguracji Wymagana konfiguracja specyficzna dla platformy IronPDF: Łatwiejsze wdrożenie
Wersje .NET .NET 10, 9, 8, 7, 6, 5, Core 3.1+, Framework 4.6.2+ .NET 10, 9, 8, 7, 6, Standard 2.0+, Framework 4.0+ Oba: Wsparcie nowoczesnego frameworka
Systemy operacyjne Windows, Linux, macOS, Docker natywnie Windows, Linux, macOS, Azure IronPDF: zoptymalizowane dla Dockera
HTML do PDF Silnik renderujący Pełny silnik Chrome V8 Niestandardowy silnik renderujący HTML IronPDF: Wysoka wierność przeglądarki
Obsługa CSS3/HTML5 Pełne wsparcie Dobre wsparcie dla standardowych funkcji IronPDF: Nowoczesne standardy internetowe
Wykonanie JavaScript Pełna obsługa JavaScript z oczekiwaniem Dobre wsparcie JavaScript IronPDF: Gotowość na dynamiczną treść
Szybkość renderowania Zoptymalizowane dla skomplikowanych stron z JavaScript Szybkie dla prostego statycznego HTML Zależy od złożoności dokumentu
Security & Encryption Poziomy szyfrowania AES-256, niestandardowe procedury obsługi Standard AES-256 Oba: Standard branżowy
Opcje uprawnień Szczegółowe kontrolki uprawnień Podstawowy zestaw uprawnień IronPDF: Precyzyjniejsza kontrola
Podpisy cyfrowe Zintegrowane, wizualne podpisy Podstawowe wsparcie podpisu IronPDF: Łatwiejsze podpisywanie
Manipulacja treścią Metoda redakcji Prawdziwe usuwanie treści, jednowierszowe API Brak wbudowanej rewizji IronPDF: Gotowość do zapewnienia zgodności
Znak wodny Oparty na HTML/CSS, pełna stylizacja Watermarki na bazie szablonów IronPDF: Bogate znaki wodne
Stemplowanie Ujednolicone klasy stempli Takie samo jak funkcja watermarking IronPDF: Dedykowane narzędzia
Konwersja plików DOCX do PDF Wbudowany DocxToPdfRenderer Requires Evo Word to PDF ($450+) IronPDF: Bez dodatkowych kosztów
Doświadczenie programisty Przykłady kodu Ponad 100 gotowych do uruchomienia przykładów Dostępne przykłady kodu IronPDF: Rozległe zasoby
Dokumentacja Samouczki, instrukcje, filmy, dokumentacja API Dokumentacja API i przykłady IronPDF: Wiele ścieżek nauki
Komunikaty błędów Opisowe, działające Standardowe raportowanie błędów IronPDF: Lepsze debugowanie
Wskaźniki wydajności Przetwarzanie dużych dokumentów Przetwarzanie wsadowe o dużej przepustowości Standardowe przetwarzanie wsadowe IronPDF: Lepsza skalowalność
Obsługa wątków Zoptymalizowane pod kątem natywnego async/await Wsparcie dla wielowątkowości IronPDF: Lepsza skalowalność
Licensing & Pricing Poziom początkowy Lite: $999 (1 deweloper, 1 projekt) Wdrożenie: $450 (1 serwer, 1 aplikacja) EvoPdf: Niższy początkowy koszt
Licencja Team Plus: $1,499 (3 deweloperów, 3 projekty) Firma: $1,200 (nielimitowani deweloperzy) EvoPdf: Lepsze dla dużych zespołów
Redystrybucja +$1,999 bez opłat licencyjnych Zawarte w Company License EvoPdf: Wbudowana redystrybucja
Opcja Suite Iron Suite: $2,998 (10 products) Toolkit EVO PDF: $1,400 IronPDF: Więcej produktów w zestawie
Wsparcie Wsparcie techniczne w cenie Tak, wsparcie inżynierskie 24/5 Tak, standardowe wsparcie techniczne w pierwszym roku IronPDF: Bezpośredni dostęp dla inżynierów
Najlepsze dla Przykłady zastosowań Nowoczesne aplikacje internetowe, złożone pliki PDF, zgodność z przepisami Proste konwersje z HTML do PDF, podstawowe konwersje Zależy od kontekstu
Uwaga. EvoPdf oferuje konkurencyjne ceny dla dużych zespołów. IronPDF zapewnia bardziej wszechstronne funkcje, w tym wbudowaną redakcję i wsparcie konwersji dokumentów.

Zrozumienie IronPDF i EvoPdf: główne atuty i filozofia

Co wyróżnia IronPDF na rynku bibliotek PDF dla platformy .NET?

IronPDF to kompleksowe rozwiązanie do obsługi plików PDF, zaprojektowane z myślą o wydajności programistów. Oparty na prostocie, ale nie tracący przy tym na mocy, IronPDF pozwala programistom .NET tworzyć, edytować i modyfikować dokumenty PDF za pomocą intuicyjnych interfejsów API, które odzwierciedlają znane wzorce tworzenia stron internetowych. Wyróżniającą cechą biblioteki jest silnik renderujący oparty na przeglądarce Chrome, który zapewnia konwersję HTML do PDF z idealną dokładnością pikselową, jednocześnie obsługując najnowsze standardy internetowe, w tym CSS3, frameworki JavaScript i czcionki internetowe.

Biblioteka sprawdza się doskonale w sytuacjach wymagających wiernego renderowania dokumentów, złożonej obróbki plików PDF oraz funkcji bezpieczeństwa na poziomie Enterprise. Jego bogaty zestaw funkcji obejmuje nie tylko podstawowe generowanie plików PDF, ale także zaawansowane możliwości, takie jak podpisy cyfrowe, wypełnianie formularzy, integracja OCR poprzez IronOCR oraz płynna konwersja formatów dokumentów. Kompatybilność międzyplatformowa IronPDF wykracza poza zwykłą obsługę frameworków, oferując natywną wydajność w systemach Windows, Linux, macOS, kontenerach Docker oraz platformach chmurowych, takich jak Azure i AWS.

Czym wyróżnia się podejście EvoPdf do generowania plików PDF?

EvoPdf stosuje bardziej tradycyjne podejście do obróbki plików PDF, skupiając się przede wszystkim na konwersji HTML do PDF, kładąc nacisk na dostosowywanie i kontrolę. Biblioteka zapewnia programistom szczegółową kontrolę nad procesem konwersji, umożliwiając precyzyjne dostosowanie parametrów renderowania, układów stron i ustawień konwersji. Architektura EvoPdf została zbudowana w oparciu o zapewnienie niezawodnych, spójnych wyników w standardowych scenariuszach konwersji stron internetowych do formatu PDF.

EvoPdf wyróżnia się przede wszystkim niewielkim obciążeniem systemu i większą szybkością renderowania prostych dokumentów HTML. Dla prostych stron HTML bez złożonych funkcji JavaScript lub CSS3, EvoPdf jest dobrze przystosowany do przetwarzania wsadowego prostych dokumentów o dużych nakładach. Biblioteka oferuje również dobre wsparcie dla renderowania po stronie serwera w środowiskach ASP.NET, z optymalizacjami dla scenariuszy aplikacji internetowych.

Jak wypada porównanie możliwości wielopłatformowych poszczególnych bibliotek?

Nowoczesna architektura wielopłatformowa IronPDF

IronPDF zapewnia płynną kompatybilność między platformami, wykraczającą poza zwykłą obsługę frameworków. Biblioteka działa natywnie na platformach:

  • Obsługa wersji .NET:

    • .NET 10, 9, 8, 7, 6, 5 oraz .NET Core 3.1+ .NET Standard 2.0+ .NET Framework 4.6.2+
    • Pełna obsługa języków C#, VB.NET i F#

  • Kompatybilność z systemami operacyjnymi: Windows (x86, x64, ARM)

    • Linux (Ubuntu, Debian, CentOS, Alpine)
    • macOS (Intel i Apple Silicon)
    • Kontenery Docker z wstępnie skonfigurowanymi obrazami
  • Integracja z platformą chmurową:
    • Usługa Azure App Service, funkcje i maszyny wirtualne
    • AWS (EC2, Lambda)
    • Google Cloud Platform
    • Wdrożenia Kubernetes

To, co wyróżnia IronPDF, to model wdrażania bez konieczności konfiguracji. W przeciwieństwie do wielu bibliotek PDF, które wymagają dodatkowych zależności lub instalacji podczas działania, IronPDF zawiera swoje niezbędne komponenty w pakiecie NuGet. To samodzielne podejście znacznie zmniejsza złożoność wdrożenia i eliminuje typowe problemy typu "działa na moim komputerze".

Wymagania i ograniczenia platformy EvoPdf

EvoPdf obsługuje podobny zakres wersji .NET, ale wymaga bardziej starannej konfiguracji w scenariuszach wielopłatformowych:

  • Obsługa platformy .NET Framework:

    • .NET 10, 9, 8, 7, i 6 .NET Standard 2.0+
    • .NET Framework 4.0+
  • Uwagi dotyczące platformy:
    • Optymalizacja przede wszystkim pod kątem środowisk Windows
    • Obsługa systemu Linux wymaga dodatkowej konfiguracji
    • Obsługa systemu macOS poprzez .NET Core
    • Wdrożenie w chmurze wymaga dostosowań specyficznych dla danej platformy

W przypadku wdrożeń wielopłatformowych użytkownicy EvoPdf często muszą radzić sobie z zależnościami i konfiguracjami specyficznymi dla danej platformy, szczególnie podczas przechodzenia między środowiskami Windows i Linux. Ta dodatkowa złożoność konfiguracji może wpłynąć na harmonogramy rozwoju i zwiększyć nakłady związane z utrzymaniem.

Która biblioteka oferuje lepszą funkcjonalność PDF do typowych zadań?

Konwersja HTML do PDF: jakość renderowania i wydajność

Najważniejszą funkcją obu bibliotek jest konwersja HTML do PDF, ale ich podejścia i wyniki znacznie się różnią.

Przykład konwersji HTML do PDF w IronPDF

using IronPdf;

// Initialize the Chrome-based renderer with advanced options
var renderer = new ChromePdfRenderer
{
    // Configure rendering options for optimal quality
    RenderingOptions = new ChromePdfRenderOptions
    {
        // Set high-quality rendering at 300 DPI for print-ready PDFs
        DPI = 300,

        // Enable JavaScript execution with custom timeout
        EnableJavaScript = true,
        RenderDelay = 2000, // Wait 2 seconds for dynamic content

        // Configure page layout
        MarginTop = 20,
        MarginBottom = 20,
        MarginLeft = 15,
        MarginRight = 15,

        // Enable modern web features
        CssMediaType = PdfCssMediaType.Print,
        ViewPortWidth = 1920,

        // Optimize for web fonts and images
        CreatePdfFormsFromHtml = true,
        FitToPaperMode = FitToPaperModes.Automatic
    }
};

// Convert complex HTML with CSS3 and JavaScript
var htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap' rel='stylesheet'>
    <style>
        body { font-family: 'Roboto', sans-serif; }
        .chart-container { width: 100%; height: 400px; }
        @media print {
            .no-print { display: none; }
            .page-break { page-break-after: always; }
        }
    </style>
    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
</head>
<body>
    <h1>Dynamic Sales Report</h1>
    <div class='chart-container'>
        <canvas id='salesChart'></canvas>
    </div>
    <script>
        // Dynamic chart generation
        const ctx = document.getElementById('salesChart').getContext('2d');
        new Chart(ctx, {
            type: 'line',
            data: {
                labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
                datasets: [{
                    label: 'Sales 2025',
                    data: [65, 78, 90, 81, 96],
                    borderColor: 'rgb(75, 192, 192)',
                    tension: 0.4
                }]
            }
        });
    </script>
</body>
</html>";

// Generate PDF with full JavaScript chart rendering
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Apply post-processing optimizations
pdf.CompressImages(90);
pdf.SaveAs("sales-report.pdf");
using IronPdf;

// Initialize the Chrome-based renderer with advanced options
var renderer = new ChromePdfRenderer
{
    // Configure rendering options for optimal quality
    RenderingOptions = new ChromePdfRenderOptions
    {
        // Set high-quality rendering at 300 DPI for print-ready PDFs
        DPI = 300,

        // Enable JavaScript execution with custom timeout
        EnableJavaScript = true,
        RenderDelay = 2000, // Wait 2 seconds for dynamic content

        // Configure page layout
        MarginTop = 20,
        MarginBottom = 20,
        MarginLeft = 15,
        MarginRight = 15,

        // Enable modern web features
        CssMediaType = PdfCssMediaType.Print,
        ViewPortWidth = 1920,

        // Optimize for web fonts and images
        CreatePdfFormsFromHtml = true,
        FitToPaperMode = FitToPaperModes.Automatic
    }
};

// Convert complex HTML with CSS3 and JavaScript
var htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap' rel='stylesheet'>
    <style>
        body { font-family: 'Roboto', sans-serif; }
        .chart-container { width: 100%; height: 400px; }
        @media print {
            .no-print { display: none; }
            .page-break { page-break-after: always; }
        }
    </style>
    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
</head>
<body>
    <h1>Dynamic Sales Report</h1>
    <div class='chart-container'>
        <canvas id='salesChart'></canvas>
    </div>
    <script>
        // Dynamic chart generation
        const ctx = document.getElementById('salesChart').getContext('2d');
        new Chart(ctx, {
            type: 'line',
            data: {
                labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
                datasets: [{
                    label: 'Sales 2025',
                    data: [65, 78, 90, 81, 96],
                    borderColor: 'rgb(75, 192, 192)',
                    tension: 0.4
                }]
            }
        });
    </script>
</body>
</html>";

// Generate PDF with full JavaScript chart rendering
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Apply post-processing optimizations
pdf.CompressImages(90);
pdf.SaveAs("sales-report.pdf");
Imports IronPdf

' Initialize the Chrome-based renderer with advanced options
Private renderer = New ChromePdfRenderer With {
	.RenderingOptions = New ChromePdfRenderOptions With {
		.DPI = 300,
		.EnableJavaScript = True,
		.RenderDelay = 2000,
		.MarginTop = 20,
		.MarginBottom = 20,
		.MarginLeft = 15,
		.MarginRight = 15,
		.CssMediaType = PdfCssMediaType.Print,
		.ViewPortWidth = 1920,
		.CreatePdfFormsFromHtml = True,
		.FitToPaperMode = FitToPaperModes.Automatic
	}
}

' Convert complex HTML with CSS3 and JavaScript
Private htmlContent = "
<!DOCTYPE html>
<html>
<head>
    <link href='https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap' rel='stylesheet'>
    <style>
        body { font-family: 'Roboto', sans-serif; }
        .chart-container { width: 100%; height: 400px; }
        @media print {
            .no-print { display: none; }
            .page-break { page-break-after: always; }
        }
    </style>
    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
</head>
<body>
    <h1>Dynamic Sales Report</h1>
    <div class='chart-container'>
        <canvas id='salesChart'></canvas>
    </div>
    <script>
        // Dynamic chart generation
        const ctx = document.getElementById('salesChart').getContext('2d');
        new Chart(ctx, {
            type: 'line',
            data: {
                labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
                datasets: [{
                    label: 'Sales 2025',
                    data: [65, 78, 90, 81, 96],
                    borderColor: 'rgb(75, 192, 192)',
                    tension: 0.4
                }]
            }
        });
    </script>
</body>
</html>"

' Generate PDF with full JavaScript chart rendering
Private pdf = renderer.RenderHtmlAsPdf(htmlContent)

' Apply post-processing optimizations
pdf.CompressImages(90)
pdf.SaveAs("sales-report.pdf")
$vbLabelText   $csharpLabel

Ten przykład IronPDF pokazuje kilka zaawansowanych funkcji:

  • Silnik JavaScript Chrome V8: w pełni obsługuje Chart.js w celu renderowania dynamicznych wizualizacji
  • Obsługa czcionek internetowych: automatyczne pobieranie i osadzanie czcionek Google Fonts
  • Responsywne renderowanie: uwzględnia zapytania o media CSS w celu optymalizacji wydruku PRINT
  • Obsługa wysokiej rozdzielczości: Generuje pliki PDF gotowe do druku w rozdzielczości 300 DPI
  • Automatyczny układ: inteligentnie dopasowuje treść do granic strony

Przykład konwersji HTML do PDF w EvoPdf

using EvoPdf;

// Create converter with configuration
HtmlToPdfConverter converter = new HtmlToPdfConverter();

// Set license key (required for production use)
converter.LicenseKey = "your-license-key";

// Configure conversion settings
converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
converter.PdfDocumentOptions.PdfPageOrientation = PdfPageOrientation.Portrait;
converter.PdfDocumentOptions.TopMargin = 20;
converter.PdfDocumentOptions.BottomMargin = 20;
converter.PdfDocumentOptions.LeftMargin = 15;
converter.PdfDocumentOptions.RightMargin = 15;

// Enable JavaScript execution
converter.JavaScriptEnabled = true;
converter.ConversionDelay = 2; // seconds

// Set authentication if needed
converter.AuthenticationOptions.Username = "username";
converter.AuthenticationOptions.Password = "password";

// Convert HTML string
string htmlString = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; }
    </style>
</head>
<body>
    <h1>Invoice</h1>
    <table>
        <tr>
            <th>Item</th>
            <th>Quantity</th>
            <th>Price</th>
        </tr>
        <tr>
            <td>Product A</td>
            <td>5</td>
            <td>$50.00</td>
        </tr>
    </table>
</body>
</html>";

// Perform conversion
byte[] pdfBytes = converter.ConvertHtml(htmlString, "");

// Save to file
System.IO.File.WriteAllBytes("invoice.pdf", pdfBytes);
using EvoPdf;

// Create converter with configuration
HtmlToPdfConverter converter = new HtmlToPdfConverter();

// Set license key (required for production use)
converter.LicenseKey = "your-license-key";

// Configure conversion settings
converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
converter.PdfDocumentOptions.PdfPageOrientation = PdfPageOrientation.Portrait;
converter.PdfDocumentOptions.TopMargin = 20;
converter.PdfDocumentOptions.BottomMargin = 20;
converter.PdfDocumentOptions.LeftMargin = 15;
converter.PdfDocumentOptions.RightMargin = 15;

// Enable JavaScript execution
converter.JavaScriptEnabled = true;
converter.ConversionDelay = 2; // seconds

// Set authentication if needed
converter.AuthenticationOptions.Username = "username";
converter.AuthenticationOptions.Password = "password";

// Convert HTML string
string htmlString = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; }
    </style>
</head>
<body>
    <h1>Invoice</h1>
    <table>
        <tr>
            <th>Item</th>
            <th>Quantity</th>
            <th>Price</th>
        </tr>
        <tr>
            <td>Product A</td>
            <td>5</td>
            <td>$50.00</td>
        </tr>
    </table>
</body>
</html>";

// Perform conversion
byte[] pdfBytes = converter.ConvertHtml(htmlString, "");

// Save to file
System.IO.File.WriteAllBytes("invoice.pdf", pdfBytes);
Imports EvoPdf

' Create converter with configuration
Private converter As New HtmlToPdfConverter()

' Set license key (required for production use)
converter.LicenseKey = "your-license-key"

' Configure conversion settings
converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4
converter.PdfDocumentOptions.PdfPageOrientation = PdfPageOrientation.Portrait
converter.PdfDocumentOptions.TopMargin = 20
converter.PdfDocumentOptions.BottomMargin = 20
converter.PdfDocumentOptions.LeftMargin = 15
converter.PdfDocumentOptions.RightMargin = 15

' Enable JavaScript execution
converter.JavaScriptEnabled = True
converter.ConversionDelay = 2 ' seconds

' Set authentication if needed
converter.AuthenticationOptions.Username = "username"
converter.AuthenticationOptions.Password = "password"

' Convert HTML string
Dim htmlString As String = "
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; }
    </style>
</head>
<body>
    <h1>Invoice</h1>
    <table>
        <tr>
            <th>Item</th>
            <th>Quantity</th>
            <th>Price</th>
        </tr>
        <tr>
            <td>Product A</td>
            <td>5</td>
            <td>$50.00</td>
        </tr>
    </table>
</body>
</html>"

' Perform conversion
Dim pdfBytes() As Byte = converter.ConvertHtml(htmlString, "")

' Save to file
System.IO.File.WriteAllBytes("invoice.pdf", pdfBytes)
$vbLabelText   $csharpLabel

Podejście EvoPdf koncentruje się na prostej konwersji HTML z dobrym wsparciem dla podstawowych stylów i układu. Chociaż dobrze radzi sobie ze standardowym HTML i CSS, może mieć trudności z nowoczesnymi funkcjami internetowymi, takimi jak CSS Grid, animacje Flexbox lub złożone frameworki JavaScript.

Zabezpieczenia i szyfrowanie plików PDF: ochrona poufnych dokumentów

W przypadku dokumentów wrażliwych bezpieczeństwo ma ogromne znaczenie. Obie biblioteki oferują funkcje szyfrowania, ale o różnym stopniu zaawansowania.

Wdrożenie zaawansowanych zabezpieczeń IronPDF

using IronPdf;
using IronPdf.Security;

// Load an existing PDF or create new one
var pdf = PdfDocument.FromFile("confidential-report.pdf");

// Configure comprehensive security settings
pdf.SecuritySettings = new SecuritySettings
{
    // Set owner password (full permissions)
    OwnerPassword = "admin-complex-password-2025",

    // Set user password (restricted permissions)
    UserPassword = "user-password-readonly",

    // Configure granular permissions
    AllowAccessibilityExtractContent = false,
    AllowAnnotations = false,
    AllowAssembleDocument = false,
    AllowCopy = false,
    AllowFillForms = true,
    AllowFullQualityPrint = false,
    AllowModifyDocument = false,
    AllowPrint = true,

    // Use strongest encryption available
    EncryptionLevel = EncryptionLevel.AES256Bit
};

// Add metadata security
pdf.MetaData.Author = "Authorized Personnel Only";
pdf.MetaData.ModifiedDate = DateTime.UtcNow;
pdf.MetaData.Title = "Confidential: Internal Use Only";

// Apply digital signature for authenticity
var signature = new PdfSignature("certificate.pfx", "cert-password")
{
    SigningReason = "Document Approval",
    SigningLocation = "Corporate Headquarters",
    SigningContact = "security@company.com",

    // Visual signature appearance
    IsVisible = true,
    X = 100,
    Y = 100,
    Width = 200,
    Height = 50,
    PageIndex = 0,

    // Custom appearance
    SignatureImage = new PdfSignatureImage("signature.png"),
    DateFormat = "yyyy-MM-dd HH:mm:ss"
};

pdf.Sign(signature);

// Add watermark for additional security
pdf.ApplyWatermark("<h2 style='color:red; opacity:0.5;'>CONFIDENTIAL</h2>", 
    45, VerticalAlignment.Middle, HorizontalAlignment.Center);

pdf.SaveAs("secured-document.pdf");
using IronPdf;
using IronPdf.Security;

// Load an existing PDF or create new one
var pdf = PdfDocument.FromFile("confidential-report.pdf");

// Configure comprehensive security settings
pdf.SecuritySettings = new SecuritySettings
{
    // Set owner password (full permissions)
    OwnerPassword = "admin-complex-password-2025",

    // Set user password (restricted permissions)
    UserPassword = "user-password-readonly",

    // Configure granular permissions
    AllowAccessibilityExtractContent = false,
    AllowAnnotations = false,
    AllowAssembleDocument = false,
    AllowCopy = false,
    AllowFillForms = true,
    AllowFullQualityPrint = false,
    AllowModifyDocument = false,
    AllowPrint = true,

    // Use strongest encryption available
    EncryptionLevel = EncryptionLevel.AES256Bit
};

// Add metadata security
pdf.MetaData.Author = "Authorized Personnel Only";
pdf.MetaData.ModifiedDate = DateTime.UtcNow;
pdf.MetaData.Title = "Confidential: Internal Use Only";

// Apply digital signature for authenticity
var signature = new PdfSignature("certificate.pfx", "cert-password")
{
    SigningReason = "Document Approval",
    SigningLocation = "Corporate Headquarters",
    SigningContact = "security@company.com",

    // Visual signature appearance
    IsVisible = true,
    X = 100,
    Y = 100,
    Width = 200,
    Height = 50,
    PageIndex = 0,

    // Custom appearance
    SignatureImage = new PdfSignatureImage("signature.png"),
    DateFormat = "yyyy-MM-dd HH:mm:ss"
};

pdf.Sign(signature);

// Add watermark for additional security
pdf.ApplyWatermark("<h2 style='color:red; opacity:0.5;'>CONFIDENTIAL</h2>", 
    45, VerticalAlignment.Middle, HorizontalAlignment.Center);

pdf.SaveAs("secured-document.pdf");
Imports IronPdf
Imports IronPdf.Security

' Load an existing PDF or create new one
Private pdf = PdfDocument.FromFile("confidential-report.pdf")

' Configure comprehensive security settings
pdf.SecuritySettings = New SecuritySettings With {
	.OwnerPassword = "admin-complex-password-2025",
	.UserPassword = "user-password-readonly",
	.AllowAccessibilityExtractContent = False,
	.AllowAnnotations = False,
	.AllowAssembleDocument = False,
	.AllowCopy = False,
	.AllowFillForms = True,
	.AllowFullQualityPrint = False,
	.AllowModifyDocument = False,
	.AllowPrint = True,
	.EncryptionLevel = EncryptionLevel.AES256Bit
}

' Add metadata security
pdf.MetaData.Author = "Authorized Personnel Only"
pdf.MetaData.ModifiedDate = DateTime.UtcNow
pdf.MetaData.Title = "Confidential: Internal Use Only"

' Apply digital signature for authenticity
Dim signature = New PdfSignature("certificate.pfx", "cert-password") With {
	.SigningReason = "Document Approval",
	.SigningLocation = "Corporate Headquarters",
	.SigningContact = "security@company.com",
	.IsVisible = True,
	.X = 100,
	.Y = 100,
	.Width = 200,
	.Height = 50,
	.PageIndex = 0,
	.SignatureImage = New PdfSignatureImage("signature.png"),
	.DateFormat = "yyyy-MM-dd HH:mm:ss"
}

pdf.Sign(signature)

' Add watermark for additional security
pdf.ApplyWatermark("<h2 style='color:red; opacity:0.5;'>CONFIDENTIAL</h2>", 45, VerticalAlignment.Middle, HorizontalAlignment.Center)

pdf.SaveAs("secured-document.pdf")
$vbLabelText   $csharpLabel

Implementacja zabezpieczeń IronPDF zapewnia funkcje klasy korporacyjnej:

  • Szczegółowe Uprawnienia: Ścisła kontrola nad tym, co użytkownicy mogą robić
  • Wizualne podpisy cyfrowe: Należy dołączyć obrazy podpisów i sygnatury czasowe
  • Ochrona metadanych: zabezpieczanie właściwości dokumentów i ścieżek audytu
  • Wielowarstwowe zabezpieczenia: połączenie szyfrowania, podpisów i znaków wodnych

Konfiguracja zabezpieczeń EvoPdf

using EvoPdf;

// Create security manager
PdfSecurityOptions securityOptions = new PdfSecurityOptions();

// Set basic security parameters
securityOptions.UserPassword = "user123";
securityOptions.OwnerPassword = "owner456";
securityOptions.KeySize = EncryptionKeySize.Key256Bit;

// Configure permissions
securityOptions.CanPrint = true;
securityOptions.CanCopyContent = false;
securityOptions.CanEditContent = false;
securityOptions.CanEditAnnotations = false;
securityOptions.CanFillFormFields = true;
securityOptions.CanAssembleDocument = false;

// Apply security to existing PDF
PdfSecurityManager securityManager = new PdfSecurityManager(securityOptions);
securityManager.SaveSecuredPdfToFile("input.pdf", "secured-output.pdf");
using EvoPdf;

// Create security manager
PdfSecurityOptions securityOptions = new PdfSecurityOptions();

// Set basic security parameters
securityOptions.UserPassword = "user123";
securityOptions.OwnerPassword = "owner456";
securityOptions.KeySize = EncryptionKeySize.Key256Bit;

// Configure permissions
securityOptions.CanPrint = true;
securityOptions.CanCopyContent = false;
securityOptions.CanEditContent = false;
securityOptions.CanEditAnnotations = false;
securityOptions.CanFillFormFields = true;
securityOptions.CanAssembleDocument = false;

// Apply security to existing PDF
PdfSecurityManager securityManager = new PdfSecurityManager(securityOptions);
securityManager.SaveSecuredPdfToFile("input.pdf", "secured-output.pdf");
Imports EvoPdf

' Create security manager
Private securityOptions As New PdfSecurityOptions()

' Set basic security parameters
securityOptions.UserPassword = "user123"
securityOptions.OwnerPassword = "owner456"
securityOptions.KeySize = EncryptionKeySize.Key256Bit

' Configure permissions
securityOptions.CanPrint = True
securityOptions.CanCopyContent = False
securityOptions.CanEditContent = False
securityOptions.CanEditAnnotations = False
securityOptions.CanFillFormFields = True
securityOptions.CanAssembleDocument = False

' Apply security to existing PDF
Dim securityManager As New PdfSecurityManager(securityOptions)
securityManager.SaveSecuredPdfToFile("input.pdf", "secured-output.pdf")
$vbLabelText   $csharpLabel

EvoPdf zapewnia podstawowe funkcje bezpieczeństwa odpowiednie do podstawowej ochrony dokumentów, choć brakuje mu niektórych zaawansowanych opcji dostępnych w IronPDF.

Redagowanie treści: zgodność z przepisami i ochrona prywatności

W dzisiejszym środowisku, w którym dużą wagę przywiązuje się do prywatności, możliwość trwałego usuwania poufnych informacji z plików PDF ma kluczowe znaczenie dla zgodności z przepisami takimi jak RODO, HIPAA i CCPA.

Przykład redagowania w IronPDF

using IronPdf;

// Load PDF containing sensitive information
PdfDocument pdf = PdfDocument.FromFile("customer-records.pdf");

// Redact using multiple strategies
// 1. Redact specific text patterns (SSN format)
pdf.RedactTextOnAllPages(@"\b\d{3}-\d{2}-\d{4}\b", 
    isRegex: true, 
    new RedactionOptions
    {
        RedactionColor = Color.Black,
        RedactionStyle = RedactionStyle.Filled,
        DrawRedactionBorder = true,
        BorderColor = Color.Red
    });

// 2. Redact specific phrases
pdf.RedactTextOnPages("Confidential", 
    new[] { 0, 1, 2 }, // Specific pages
    caseSensitive: false);

// 3. Redact regions by coordinates
pdf.RedactRegion(new Rectangle(100, 200, 300, 50), 0);

// 4. Use advanced pattern matching for credit cards
string creditCardPattern = @"\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b";
pdf.RedactTextOnAllPages(creditCardPattern, isRegex: true);

// Apply OCR-based redaction for scanned documents
pdf.ApplyOcr(new TesseractLanguage[] { TesseractLanguage.English });
pdf.RedactTextOnAllPages("Salary:");

// Save with audit trail
pdf.MetaData.CustomProperties.Add("Redacted", DateTime.UtcNow.ToString());
pdf.MetaData.CustomProperties.Add("RedactedBy", Environment.UserName);
pdf.SaveAs("redacted-records.pdf");
using IronPdf;

// Load PDF containing sensitive information
PdfDocument pdf = PdfDocument.FromFile("customer-records.pdf");

// Redact using multiple strategies
// 1. Redact specific text patterns (SSN format)
pdf.RedactTextOnAllPages(@"\b\d{3}-\d{2}-\d{4}\b", 
    isRegex: true, 
    new RedactionOptions
    {
        RedactionColor = Color.Black,
        RedactionStyle = RedactionStyle.Filled,
        DrawRedactionBorder = true,
        BorderColor = Color.Red
    });

// 2. Redact specific phrases
pdf.RedactTextOnPages("Confidential", 
    new[] { 0, 1, 2 }, // Specific pages
    caseSensitive: false);

// 3. Redact regions by coordinates
pdf.RedactRegion(new Rectangle(100, 200, 300, 50), 0);

// 4. Use advanced pattern matching for credit cards
string creditCardPattern = @"\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b";
pdf.RedactTextOnAllPages(creditCardPattern, isRegex: true);

// Apply OCR-based redaction for scanned documents
pdf.ApplyOcr(new TesseractLanguage[] { TesseractLanguage.English });
pdf.RedactTextOnAllPages("Salary:");

// Save with audit trail
pdf.MetaData.CustomProperties.Add("Redacted", DateTime.UtcNow.ToString());
pdf.MetaData.CustomProperties.Add("RedactedBy", Environment.UserName);
pdf.SaveAs("redacted-records.pdf");
Imports IronPdf

' Load PDF containing sensitive information
Private pdf As PdfDocument = PdfDocument.FromFile("customer-records.pdf")

' Redact using multiple strategies
' 1. Redact specific text patterns (SSN format)
pdf.RedactTextOnAllPages("\b\d{3}-\d{2}-\d{4}\b", isRegex:= True, New RedactionOptions With {
	.RedactionColor = Color.Black,
	.RedactionStyle = RedactionStyle.Filled,
	.DrawRedactionBorder = True,
	.BorderColor = Color.Red
})

' 2. Redact specific phrases
pdf.RedactTextOnPages("Confidential", { 0, 1, 2 }, caseSensitive:= False)

' 3. Redact regions by coordinates
pdf.RedactRegion(New Rectangle(100, 200, 300, 50), 0)

' 4. Use advanced pattern matching for credit cards
Dim creditCardPattern As String = "\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b"
pdf.RedactTextOnAllPages(creditCardPattern, isRegex:= True)

' Apply OCR-based redaction for scanned documents
pdf.ApplyOcr(New TesseractLanguage() { TesseractLanguage.English })
pdf.RedactTextOnAllPages("Salary:")

' Save with audit trail
pdf.MetaData.CustomProperties.Add("Redacted", DateTime.UtcNow.ToString())
pdf.MetaData.CustomProperties.Add("RedactedBy", Environment.UserName)
pdf.SaveAs("redacted-records.pdf")
$vbLabelText   $csharpLabel

Funkcje redagowania w IronPDF obejmują:

  • True Content Removal: Trwale usuwa tekst, a nie tylko go zakrywa
  • Rozpoznawanie wzorców: obsługa wyrażeń regularnych dla numerów SSN, kart kredytowych, adresów e-mail
  • Style wizualnej redakcji: Konfigurowalny wygląd ścieżek audytu
  • Integracja OCR: redagowanie tekstu w zeskanowanych dokumentach
  • Selektywna redakcja: wybierz konkretne strony lub regiony

IronPDF zawiera wbudowaną funkcję zaciemniania, co czyni go dobrym wyborem dla aplikacji wymagających zgodności z przepisami o ochronie prywatności, takimi jak GDPR, HIPAA i CCPA.

Obsługa formularzy: tworzenie interaktywnych plików PDF

Obie biblioteki obsługują formularze PDF, ale mają różne podejścia do ich tworzenia i edycji.

Przykład formularzy IronPDF

using IronPdf;
using IronPdf.Forms;

// Create a new PDF with an HTML form
var html = @"
<html>
<body>
    <h2>Employee Information Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' required />

        <label>Email:</label>
        <input type='email' name='email' required />

        <label>Department:</label>
        <select name='department'>
            <option value=''>Select Department</option>
            <option value='IT'>Information Technology</option>
            <option value='HR'>Human Resources</option>
            <option value='Sales'>Sales</option>
        </select>

        <label>Start Date:</label>
        <input type='date' name='startDate' />

        <label>
            <input type='checkbox' name='agreement' />
            I agree to the terms and conditions
        </label>

        <button type='submit'>Submit</button>
    </form>
</body>
</html>";

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        CreatePdfFormsFromHtml = true // Enable form field creation
    }
};

var pdf = renderer.RenderHtmlAsPdf(html);

// Programmatically fill form fields
pdf.Form.SetFieldValue("fullName", "John Doe");
pdf.Form.SetFieldValue("email", "john.doe@company.com");
pdf.Form.SetFieldValue("department", "IT");
pdf.Form.SetFieldValue("startDate", DateTime.Now.ToString("yyyy-MM-dd"));
pdf.Form.SetCheckBoxValue("agreement", true);

// Make specific fields read-only
pdf.Form.Fields["email"].ReadOnly = true;

// Add form field validation
foreach (var field in pdf.Form.Fields)
{
    if (field.Name == "email")
    {
        field.Annotation.BorderColor = Color.Blue;
        field.Annotation.BackgroundColor = Color.LightGray;
    }
}

// Flatten form (convert to static content)
var flattenedPdf = pdf.Flatten();
flattenedPdf.SaveAs("completed-form.pdf");

// Or save as fillable form
pdf.SaveAs("fillable-form.pdf");
using IronPdf;
using IronPdf.Forms;

// Create a new PDF with an HTML form
var html = @"
<html>
<body>
    <h2>Employee Information Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' required />

        <label>Email:</label>
        <input type='email' name='email' required />

        <label>Department:</label>
        <select name='department'>
            <option value=''>Select Department</option>
            <option value='IT'>Information Technology</option>
            <option value='HR'>Human Resources</option>
            <option value='Sales'>Sales</option>
        </select>

        <label>Start Date:</label>
        <input type='date' name='startDate' />

        <label>
            <input type='checkbox' name='agreement' />
            I agree to the terms and conditions
        </label>

        <button type='submit'>Submit</button>
    </form>
</body>
</html>";

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        CreatePdfFormsFromHtml = true // Enable form field creation
    }
};

var pdf = renderer.RenderHtmlAsPdf(html);

// Programmatically fill form fields
pdf.Form.SetFieldValue("fullName", "John Doe");
pdf.Form.SetFieldValue("email", "john.doe@company.com");
pdf.Form.SetFieldValue("department", "IT");
pdf.Form.SetFieldValue("startDate", DateTime.Now.ToString("yyyy-MM-dd"));
pdf.Form.SetCheckBoxValue("agreement", true);

// Make specific fields read-only
pdf.Form.Fields["email"].ReadOnly = true;

// Add form field validation
foreach (var field in pdf.Form.Fields)
{
    if (field.Name == "email")
    {
        field.Annotation.BorderColor = Color.Blue;
        field.Annotation.BackgroundColor = Color.LightGray;
    }
}

// Flatten form (convert to static content)
var flattenedPdf = pdf.Flatten();
flattenedPdf.SaveAs("completed-form.pdf");

// Or save as fillable form
pdf.SaveAs("fillable-form.pdf");
Imports IronPdf
Imports IronPdf.Forms

' Create a new PDF with an HTML form
Private html = "
<html>
<body>
    <h2>Employee Information Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' required />

        <label>Email:</label>
        <input type='email' name='email' required />

        <label>Department:</label>
        <select name='department'>
            <option value=''>Select Department</option>
            <option value='IT'>Information Technology</option>
            <option value='HR'>Human Resources</option>
            <option value='Sales'>Sales</option>
        </select>

        <label>Start Date:</label>
        <input type='date' name='startDate' />

        <label>
            <input type='checkbox' name='agreement' />
            I agree to the terms and conditions
        </label>

        <button type='submit'>Submit</button>
    </form>
</body>
</html>"

Private renderer = New ChromePdfRenderer With {
	.RenderingOptions = New ChromePdfRenderOptions With {.CreatePdfFormsFromHtml = True}
}

Private pdf = renderer.RenderHtmlAsPdf(html)

' Programmatically fill form fields
pdf.Form.SetFieldValue("fullName", "John Doe")
pdf.Form.SetFieldValue("email", "john.doe@company.com")
pdf.Form.SetFieldValue("department", "IT")
pdf.Form.SetFieldValue("startDate", DateTime.Now.ToString("yyyy-MM-dd"))
pdf.Form.SetCheckBoxValue("agreement", True)

' Make specific fields read-only
pdf.Form.Fields("email").ReadOnly = True

' Add form field validation
For Each field In pdf.Form.Fields
	If field.Name = "email" Then
		field.Annotation.BorderColor = Color.Blue
		field.Annotation.BackgroundColor = Color.LightGray
	End If
Next field

' Flatten form (convert to static content)
Dim flattenedPdf = pdf.Flatten()
flattenedPdf.SaveAs("completed-form.pdf")

' Or save as fillable form
pdf.SaveAs("fillable-form.pdf")
$vbLabelText   $csharpLabel

Funkcje obsługi formularzy w IronPDF:

  • Automatyczne generowanie formularzy: Konwertuje formularze HTML na formularze PDF
  • Manipulacja programowa: Wypełnianie, odczytywanie i modyfikowanie pól formularzy za pośrednictwem API
  • Typy pól: tekstowe, pola wyboru, przyciski opcji, listy rozwijane, pola podpisu
  • Walidacja: Ustawianie właściwości i ograniczeń pól
  • Spłaszczanie formularzy: Konwersja wypełnionych formularzy do statycznych plików PDF

Testy wydajności: scenariusze z życia wzięte

Charakterystyka wydajności różni się znacznie w zależności od złożoności dokumentu i przypadku użycia:

Test Wydajności Przetwarzania Partie

// Performance comparison for batch processing
public class PerformanceBenchmark
{
    public static async Task RunBenchmark()
    {
        var htmlTemplates = GenerateInvoiceTemplates(1000);
        var stopwatch = new Stopwatch();

        // IronPDF batch processing with optimization
        Console.WriteLine("IronPDF Batch Processing:");
        stopwatch.Start();

        var renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                RenderDelay = 0, // No delay for static content
                EnableJavaScript = false, // Disable JS for speed
                DPI = 150 // Lower DPI for faster rendering
            }
        };

        // Parallel processing
        var tasks = htmlTemplates.Select(async (html, index) =>
        {
            var pdf = await renderer.RenderHtmlAsPdfAsync(html);
            await pdf.SaveAsAsync($"ironpdf-invoice-{index}.pdf");
        });

        await Task.WhenAll(tasks);

        stopwatch.Stop();
        Console.WriteLine($"Time: {stopwatch.ElapsedMilliseconds}ms");
        Console.WriteLine($"Average: {stopwatch.ElapsedMilliseconds / 1000.0}ms per PDF");

        // Memory usage
        var process = Process.GetCurrentProcess();
        Console.WriteLine($"Memory: {process.WorkingSet64 / 1024 / 1024}MB");
    }
}
// Performance comparison for batch processing
public class PerformanceBenchmark
{
    public static async Task RunBenchmark()
    {
        var htmlTemplates = GenerateInvoiceTemplates(1000);
        var stopwatch = new Stopwatch();

        // IronPDF batch processing with optimization
        Console.WriteLine("IronPDF Batch Processing:");
        stopwatch.Start();

        var renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                RenderDelay = 0, // No delay for static content
                EnableJavaScript = false, // Disable JS for speed
                DPI = 150 // Lower DPI for faster rendering
            }
        };

        // Parallel processing
        var tasks = htmlTemplates.Select(async (html, index) =>
        {
            var pdf = await renderer.RenderHtmlAsPdfAsync(html);
            await pdf.SaveAsAsync($"ironpdf-invoice-{index}.pdf");
        });

        await Task.WhenAll(tasks);

        stopwatch.Stop();
        Console.WriteLine($"Time: {stopwatch.ElapsedMilliseconds}ms");
        Console.WriteLine($"Average: {stopwatch.ElapsedMilliseconds / 1000.0}ms per PDF");

        // Memory usage
        var process = Process.GetCurrentProcess();
        Console.WriteLine($"Memory: {process.WorkingSet64 / 1024 / 1024}MB");
    }
}
' Performance comparison for batch processing
Public Class PerformanceBenchmark
	Public Shared Async Function RunBenchmark() As Task
		Dim htmlTemplates = GenerateInvoiceTemplates(1000)
		Dim stopwatch As New Stopwatch()

		' IronPDF batch processing with optimization
		Console.WriteLine("IronPDF Batch Processing:")
		stopwatch.Start()

		Dim renderer = New ChromePdfRenderer With {
			.RenderingOptions = New ChromePdfRenderOptions With {
				.RenderDelay = 0,
				.EnableJavaScript = False,
				.DPI = 150
			}
		}

		' Parallel processing
		Dim tasks = htmlTemplates.Select(Async Function(html, index)
			Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
			Await pdf.SaveAsAsync($"ironpdf-invoice-{index}.pdf")
		End Function)

		Await Task.WhenAll(tasks)

		stopwatch.Stop()
		Console.WriteLine($"Time: {stopwatch.ElapsedMilliseconds}ms")
		Console.WriteLine($"Average: {stopwatch.ElapsedMilliseconds / 1000.0}ms per PDF")

		' Memory usage
		Dim process As System.Diagnostics.Process = System.Diagnostics.Process.GetCurrentProcess()
		Console.WriteLine($"Memory: {process.WorkingSet64 \ 1024 \ 1024}MB")
	End Function
End Class
$vbLabelText   $csharpLabel

Rozważania wydajnościowe według scenariusza:

  • Prosty HTML: EvoPdf z reguły jest szybszy w przypadku lekkich statycznych dokumentów dzięki lżejszemu silnikowi renderującemu
  • Złożony JavaScript: IronPDF zapewnia bardziej niezawodne wyniki; EvoPdf może generować niespójne wyniki przy dynamicznej treści
  • Przetwarzanie Partie: IronPDF oferuje lepsze natywne wsparcie dla async/await równoległości
  • Zużycie Pamięci: EvoPdf ma niższą podstawę pamięci; IronPDF jest zoptymalizowany dla zadań o dużej przepustowości
  • Duże Dokumenty: IronPDF obsługuje dokumenty o dużej liczbie stron z optymalizowanym przetwarzaniem partiami

Jak Porównać Modele Cenowe dla Różnych Rozmiarów Zespołów?

Struktura licencji IronPDF

IronPDF oferuje różne opcje cenowe, w tym licencje Lite, Plus i Professional, z opcją redystrybucji bez opłat licencyjnych. Model licencjonowania jest zaprojektowany tak, aby skalować się z potrzebami zespołu i projektu (ceny na kwiecień 2026):

  • Lite License: $999

    • 1 programista
    • 1 lokalizacja
    • 1 projekt
    • Wsparcie e-mail
    • Idealna dla: Indywidualni deweloperzy, małe projekty

  • Plus License: $1,499

    • 3 programistów
    • 3 lokalizacje
    • 3 projekty
    • Wsparcie e-mail, czat i telefon
    • Idealna dla: Małe zespoły, wiele projektów

  • Professional License: $2,999

    • 10 programistów
    • 10 lokalizacji
    • 10 projektów
    • Priorytetowe wsparcie techniczne z udostępnianiem ekranu
    • Idealna dla: Średnie do dużych zespoły
  • Dodatkowe Opcje:
    • Redystrybucja bez opłat licencyjnych: +$2,999
    • 5-letnie wsparcie i aktualizacje: 1 999 USD (lub 999 USD/rok)
    • Iron Suite: $2,998 dla wszystkich 10 produktów Iron Software

Opcje Licencjonowania EvoPdf

EVO PDF Toolkit oraz samodzielny konwerter HTML na PDF oferują dwa poziomy licencji — Deployment i Company (ceny na kwiecień 2026; sprawdź aktualne ceny na evopdf.com/buy.aspx):

  • Licencja Deployment:

    • EVO HTML to PDF: $450
    • EVO PDF Toolkit: $650
    • Jeden serwer, jedna aplikacja
    • Redystrybucja nie jest wliczona
    • Standardowe wsparcie przez pierwszy rok
  • Licencja Company:
    • EVO HTML to PDF: $1,200
    • Toolkit EVO PDF: $1,400
    • Nieograniczona liczba programistów
    • Nieograniczone wdrożenia
    • Pełne prawa redystrybucji
    • Priorytetowe wsparcie przez pierwszy rok

Analiza Całkowitego Kosztu Posiadania

Przeanalizujmy scenariusze z rzeczywistego świata, aby zrozumieć rzeczywiste implikacje kosztowe:

Scenariusz 1: Startup z 2 Deweloperami

  • IronPDF Lite: $999 (pojedynczy deweloper; wymaga 2 licencji dla zespołu 2-osobowego)
  • EvoPdf Company: $1,200 (obejmuje nieograniczoną liczbę deweloperów)
  • Zwycięzca: EvoPdf dla początkowego kosztu zespołu

Scenariusz 2: Rozwijający się Zespół (5 Deweloperów, Wiele Projektów)

  • IronPDF Plus: $1,499 (obejmuje do 3 deweloperów, potrzebujesz Professional dla 5)
  • IronPDF Professional: $2,999
  • EvoPdf Company: $1,200
  • Zwycięzca: EvoPdf dla skalowania zespołu

Scenariusz 3: Przedsiębiorstwo Potrzebujące Wielu Narzędzi PDF

  • IronPDF Professional + IronOCR + IronBarcode: wiele licencji indywidualnych
  • Iron Suite: $2,998 (wszystkie 10 produktów)
  • EvoPdf Toolkit + Dodatkowe Narzędzia: $1,400+ za narzędzie
  • Zwycięzca: Iron Suite dla kompleksowych potrzeb

Scenariusz 4: Produkt SaaS z Redystrybucją

  • IronPDF Professional + Redystrybucja: $2,999 + $2,999
  • EvoPdf Company: $1,200 (uwzględnia redystrybucję)
  • Zwycięzca: EvoPdf dla scenariuszy redystrybucji

Jak Wpływają Nowoczesne Frameworki CSS na Twój Wybór?

Często niedocenianym czynnikiem przy wyborze biblioteki PDF jest wsparcie dla nowoczesnych frameworków CSS. Zdominowanie web developingu przez Bootstrap, Tailwind CSS i Foundation, zdolność twojej biblioteki do obsługi tych frameworków bezpośrednio wpływa na efektywność produkcji i jakość wyników.

IronPDF: Wszechstronne Wsparcie dla Frameworków

Pełny silnik Chrome V8 w IronPDF zapewnia natywne wsparcie dla wszystkich nowoczesnych frameworków CSS bez kompromisów:

  • Bootstrap 5: Pełne wsparcie dla flexbox i CSS Grid dla skomplikowanych układów
  • Tailwind CSS: Wszystkie klasy użytkowe renderują się dokładnie
  • Nowoczesny CSS3: Transforms, animacje, własności niestandardowe są obsługiwane
  • Walidacja produkcyjna: Sukces renderuje stronę główną Bootstrap oraz szablony Bootstrap

Przykład Kodu: Komponent Oś czasu Bootstrap

using IronPdf;

var renderer = new ChromePdfRenderer();

string bootstrapTimeline = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
    <style>
        .timeline { position: relative; padding: 20px 0; }
        .timeline::before {
            content: '';
            position: absolute;
            left: 50%;
            width: 2px;
            height: 100%;
            background: #dee2e6;
        }
        .timeline-item { position: relative; margin: 20px 0; }
    </style>
</head>
<body>
    <div class='container py-5'>
        <h2 class='text-center mb-5'>Project Timeline</h2>
        <div class='timeline'>
            <div class='timeline-item'>
                <div class='row'>
                    <div class='col-md-6'>
                        <div class='card shadow-sm'>
                            <div class='card-body'>
                                <h5 class='card-title'>Phase 1: Planning</h5>
                                <p class='text-muted'>Q1 2025</p>
                                <p class='card-text'>Initial project scope and requirements gathering completed.</p>
                                <span class='badge bg-success'>Completed</span>
                            </div>
                        </div>
                    </div>
                </div>
            </div>

        </div>
    </div>
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(bootstrapTimeline);
pdf.SaveAs("project-timeline.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

string bootstrapTimeline = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
    <style>
        .timeline { position: relative; padding: 20px 0; }
        .timeline::before {
            content: '';
            position: absolute;
            left: 50%;
            width: 2px;
            height: 100%;
            background: #dee2e6;
        }
        .timeline-item { position: relative; margin: 20px 0; }
    </style>
</head>
<body>
    <div class='container py-5'>
        <h2 class='text-center mb-5'>Project Timeline</h2>
        <div class='timeline'>
            <div class='timeline-item'>
                <div class='row'>
                    <div class='col-md-6'>
                        <div class='card shadow-sm'>
                            <div class='card-body'>
                                <h5 class='card-title'>Phase 1: Planning</h5>
                                <p class='text-muted'>Q1 2025</p>
                                <p class='card-text'>Initial project scope and requirements gathering completed.</p>
                                <span class='badge bg-success'>Completed</span>
                            </div>
                        </div>
                    </div>
                </div>
            </div>

        </div>
    </div>
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(bootstrapTimeline);
pdf.SaveAs("project-timeline.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

Dim bootstrapTimeline As String = "
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
    <style>
        .timeline { position: relative; padding: 20px 0; }
        .timeline::before {
            content: '';
            position: absolute;
            left: 50%;
            width: 2px;
            height: 100%;
            background: #dee2e6;
        }
        .timeline-item { position: relative; margin: 20px 0; }
    </style>
</head>
<body>
    <div class='container py-5'>
        <h2 class='text-center mb-5'>Project Timeline</h2>
        <div class='timeline'>
            <div class='timeline-item'>
                <div class='row'>
                    <div class='col-md-6'>
                        <div class='card shadow-sm'>
                            <div class='card-body'>
                                <h5 class='card-title'>Phase 1: Planning</h5>
                                <p class='text-muted'>Q1 2025</p>
                                <p class='card-text'>Initial project scope and requirements gathering completed.</p>
                                <span class='badge bg-success'>Completed</span>
                            </div>
                        </div>
                    </div>
                </div>
            </div>

        </div>
    </div>
</body>
</html>"

Dim pdf = renderer.RenderHtmlAsPdf(bootstrapTimeline)
pdf.SaveAs("project-timeline.pdf")
$vbLabelText   $csharpLabel

EvoPdf: Dobre Wsparcie CSS z Ograniczeniami

Niestandardowy silnik renderowania HTML w EvoPdf zapewnia solidne wsparcie CSS z pewnymi ograniczeniami dla nowoczesnych frameworków:

  • Bootstrap 3: Generalnie działa dobrze z starszymi wersjami Bootstrap
  • Bootstrap 4+: Układy flexbox mogą wymagać dostosowań
  • Wsparcie CSS3: Dobre pokrycie (~90%), ale nie kompletne
  • Dostępne obejścia: Manualne dostosowania CSS często są konieczne dla skomplikowanych układów

Rozważania Praktyczne:

Według doświadczenia programistów:

  • Podstawowe komponenty Bootstrap (przyciski, alerty, tabele) generalnie renderują się poprawnie
  • Zaawansowane komponenty (paski nawigacyjne, modale, złożone siatki) mogą wymagać dostosowania
  • Układy CSS Grid wymagają testów i możliwych obejść
  • Niestandardowe motywy Bootstrap niekiedy mają nieoczekiwane problemy z renderowaniem

Wpływ na Rozwój: Jeśli twoja aplikacja intensywnie korzysta z Bootstrap do jej interfejsu użytkownika i musisz generować raporty lub dokumenty, które pasują do twojego interfejsu webowego, bezproblemowe renderowanie IronPDF oszczędza znaczącą ilość czasu na rozwój. EvoPdf może wymagać tworzenia oddzielnych, uproszczonych wersji twoich szablonów specjalnie do generacji PDF.

Dla pełnych informacji na temat kompatybilności frameworków CSS, zobacz Przewodnik CSS Bootstrap & Flexbox.

Jakie Opcje Dokumentacji i Wsparcia Lepiej Służą Deweloperom?

Zasoby Dla Programistów IronPDF

IronPDF dostarcza kompleksową dokumentację, wsparcie inżynierów 24/5, samouczki wideo, forum społeczności i regularne aktualizacje. Ekosystem wsparcia obejmuje:

Struktura wsparcia EvoPdf

EvoPdf zapewnia dokumentację i wsparcie poprzez:

  • Dokumentacja:

    • Dokumentacja API
    • Przykłady kodu dla typowych scenariuszy
    • Sekcja z demonstracją na żywo na stronie internetowej
    • Podstawowe przewodniki dotyczące rozwiązywania problemów
  • Opcje wsparcia:
    • Pomoc techniczna przez e-mail i telefon (wliczona w cenę przez pierwszy rok)
    • Poziomy wsparcia: standardowy vs. priorytetowy
    • Forum wsparcia dla pomocy społeczności
    • Wymagane odnowienie po pierwszym roku

Kluczowym czynnikiem wyróżniającym jest inwestycja IronPDF w treści edukacyjne i bezpośrednie wsparcie inżynieryjne, co znacznie skraca czas nauki i rozwiązywania problemów.

Jakie są najlepsze zastosowania każdej z bibliotek?

Kiedy wybrać IronPDF

IronPDF doskonale sprawdza się w sytuacjach wymagających:

1. Integracja nowoczesnych aplikacji internetowych

  • Platformy SaaS generujące dynamiczne raporty
  • Witryny e-commerce tworzące faktury z wykresami
  • Panele analityczne eksportowane do formatu PDF
  • Aplikacje wykorzystujące React, Angular lub Vue.js

2. Wymagania dotyczące zgodności i bezpieczeństwa

  • Systemy opieki zdrowotnej wymagające zgodności z HIPAA
  • Usługi finansowe wymagające ścieżek audytu
  • Zarządzanie dokumentami prawnymi z redakcją
  • Aplikacje rządowe z wymogąmi bezpieczeństwa

3. Przetwarzanie złożonych dokumentów

  • Konwersja dokumentów w wielu formatach (DOCX, HTML, obrazy)
  • Integracja OCR dla skanowanych dokumentów
  • Przetwarzanie wsadowe z równoległym wykonywaniem
  • Dokumenty z podpisami cyfrowymi

4. Wdrażanie wielopłatformowe

  • Aplikacje w kontenerach Docker
  • Wdrożenia w chmurze oparte na systemie Linux
  • Architektury mikrousług
  • Funkcje bezserwerowe (AWS Lambda, Azure Functions)

Przykład z życia: Generowanie raportów dotyczących opieki zdrowotnej

public class HealthcareReportGenerator
{
    private readonly ChromePdfRenderer _renderer;

    public HealthcareReportGenerator()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                DPI = 300, // High quality for medical imaging
                EnableJavaScript = true,
                RenderDelay = 3000, // Allow charts to fully render
                CreatePdfFormsFromHtml = true
            }
        };
    }

    public async Task<byte[]> GeneratePatientReport(PatientData patient)
    {
        // Generate HTML with patient data and charts
        var html = await GenerateReportHtml(patient);

        // Convert to PDF
        var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

        // Apply security and compliance
        pdf.SecuritySettings = new SecuritySettings
        {
            AllowPrint = true,
            AllowCopy = false,
            EncryptionLevel = EncryptionLevel.AES256Bit,
            UserPassword = patient.AccessCode
        };

        // Redact SSN except last 4 digits
        pdf.RedactTextOnAllPages(@"\b\d{3}-\d{2}-(\d{4})\b", 
            replacement: "XXX-XX-$1", 
            isRegex: true);

        // Add audit metadata
        pdf.MetaData.Author = "Healthcare System";
        pdf.MetaData.Title = $"Patient Report - {patient.PatientId}";
        pdf.MetaData.CreationDate = DateTime.UtcNow;
        pdf.MetaData.CustomProperties.Add("HIPAA_Compliant", "true");

        // Add digital signature
        var signature = new PdfSignature("hospital-cert.pfx", "password")
        {
            SigningReason = "Medical Record Authenticity",
            SigningLocation = "Hospital Name"
        };
        pdf.Sign(signature);

        return pdf.BinaryData;
    }
}
public class HealthcareReportGenerator
{
    private readonly ChromePdfRenderer _renderer;

    public HealthcareReportGenerator()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                DPI = 300, // High quality for medical imaging
                EnableJavaScript = true,
                RenderDelay = 3000, // Allow charts to fully render
                CreatePdfFormsFromHtml = true
            }
        };
    }

    public async Task<byte[]> GeneratePatientReport(PatientData patient)
    {
        // Generate HTML with patient data and charts
        var html = await GenerateReportHtml(patient);

        // Convert to PDF
        var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

        // Apply security and compliance
        pdf.SecuritySettings = new SecuritySettings
        {
            AllowPrint = true,
            AllowCopy = false,
            EncryptionLevel = EncryptionLevel.AES256Bit,
            UserPassword = patient.AccessCode
        };

        // Redact SSN except last 4 digits
        pdf.RedactTextOnAllPages(@"\b\d{3}-\d{2}-(\d{4})\b", 
            replacement: "XXX-XX-$1", 
            isRegex: true);

        // Add audit metadata
        pdf.MetaData.Author = "Healthcare System";
        pdf.MetaData.Title = $"Patient Report - {patient.PatientId}";
        pdf.MetaData.CreationDate = DateTime.UtcNow;
        pdf.MetaData.CustomProperties.Add("HIPAA_Compliant", "true");

        // Add digital signature
        var signature = new PdfSignature("hospital-cert.pfx", "password")
        {
            SigningReason = "Medical Record Authenticity",
            SigningLocation = "Hospital Name"
        };
        pdf.Sign(signature);

        return pdf.BinaryData;
    }
}
Public Class HealthcareReportGenerator
	Private ReadOnly _renderer As ChromePdfRenderer

	Public Sub New()
		_renderer = New ChromePdfRenderer With {
			.RenderingOptions = New ChromePdfRenderOptions With {
				.DPI = 300,
				.EnableJavaScript = True,
				.RenderDelay = 3000,
				.CreatePdfFormsFromHtml = True
			}
		}
	End Sub

	Public Async Function GeneratePatientReport(ByVal patient As PatientData) As Task(Of Byte())
		' Generate HTML with patient data and charts
		Dim html = Await GenerateReportHtml(patient)

		' Convert to PDF
		Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)

		' Apply security and compliance
		pdf.SecuritySettings = New SecuritySettings With {
			.AllowPrint = True,
			.AllowCopy = False,
			.EncryptionLevel = EncryptionLevel.AES256Bit,
			.UserPassword = patient.AccessCode
		}

		' Redact SSN except last 4 digits
		pdf.RedactTextOnAllPages("\b\d{3}-\d{2}-(\d{4})\b", replacement:= "XXX-XX-$1", isRegex:= True)

		' Add audit metadata
		pdf.MetaData.Author = "Healthcare System"
		pdf.MetaData.Title = $"Patient Report - {patient.PatientId}"
		pdf.MetaData.CreationDate = DateTime.UtcNow
		pdf.MetaData.CustomProperties.Add("HIPAA_Compliant", "true")

		' Add digital signature
		Dim signature = New PdfSignature("hospital-cert.pfx", "password") With {
			.SigningReason = "Medical Record Authenticity",
			.SigningLocation = "Hospital Name"
		}
		pdf.Sign(signature)

		Return pdf.BinaryData
	End Function
End Class
$vbLabelText   $csharpLabel

Kiedy wybrać EvoPdf

EvoPdf doskonale nadaje się do:

1. Prosta konwersja HTML do PDF

  • Podstawowe raporty bez skomplikowanego kodu JavaScript
  • Statyczne szablony HTML
  • Proste faktury i pokwitowania
  • Masowe generowanie dokumentów przy użyciu spójnych szablonów

2. Zespoły dbające o budżet

  • Nieograniczona liczba programistów na jednej licencji
  • Niższy koszt wejścia dla podstawowych funkcji
  • Projekty niewymagające zaawansowanej obróbki plików PDF

3. Konkretne środowiska serwerowe

  • Wdrożenia oparte na systemie Windows
  • Aplikacje o prostych wymaganiach dotyczących plików PDF
  • Integracja starszych systemów

4. Proste konwersje o dużej objętości

  • Archiwizacja wiadomości e-mail do formatu PDF
  • Generowanie statycznych raportów
  • Systemy dokumentacji
  • Tworzenie dokumentów gotowych do druku

Przykład z życia: System generowania faktur

public class InvoiceGenerator
{
    private readonly HtmlToPdfConverter _converter;

    public InvoiceGenerator()
    {
        _converter = new HtmlToPdfConverter
        {
            LicenseKey = "your-license-key",
            JavaScriptEnabled = false, // Not needed for static invoices
            ConversionDelay = 0
        };

        // Configure for A4 invoices
        _converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
        _converter.PdfDocumentOptions.TopMargin = 30;
        _converter.PdfDocumentOptions.BottomMargin = 30;
    }

    public byte[] GenerateInvoice(InvoiceData data)
    {
        // Load HTML template
        var template = File.ReadAllText("invoice-template.html");

        // Simple string replacement for data
        var html = template
            .Replace("{{InvoiceNumber}}", data.InvoiceNumber)
            .Replace("{{Date}}", data.Date.ToString("yyyy-MM-dd"))
            .Replace("{{CustomerName}}", data.CustomerName)
            .Replace("{{Total}}", data.Total.ToString("C"));

        // Convert to PDF
        return _converter.ConvertHtml(html, "");
    }
}
public class InvoiceGenerator
{
    private readonly HtmlToPdfConverter _converter;

    public InvoiceGenerator()
    {
        _converter = new HtmlToPdfConverter
        {
            LicenseKey = "your-license-key",
            JavaScriptEnabled = false, // Not needed for static invoices
            ConversionDelay = 0
        };

        // Configure for A4 invoices
        _converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
        _converter.PdfDocumentOptions.TopMargin = 30;
        _converter.PdfDocumentOptions.BottomMargin = 30;
    }

    public byte[] GenerateInvoice(InvoiceData data)
    {
        // Load HTML template
        var template = File.ReadAllText("invoice-template.html");

        // Simple string replacement for data
        var html = template
            .Replace("{{InvoiceNumber}}", data.InvoiceNumber)
            .Replace("{{Date}}", data.Date.ToString("yyyy-MM-dd"))
            .Replace("{{CustomerName}}", data.CustomerName)
            .Replace("{{Total}}", data.Total.ToString("C"));

        // Convert to PDF
        return _converter.ConvertHtml(html, "");
    }
}
Public Class InvoiceGenerator
	Private ReadOnly _converter As HtmlToPdfConverter

	Public Sub New()
		_converter = New HtmlToPdfConverter With {
			.LicenseKey = "your-license-key",
			.JavaScriptEnabled = False,
			.ConversionDelay = 0
		}

		' Configure for A4 invoices
		_converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4
		_converter.PdfDocumentOptions.TopMargin = 30
		_converter.PdfDocumentOptions.BottomMargin = 30
	End Sub

	Public Function GenerateInvoice(ByVal data As InvoiceData) As Byte()
		' Load HTML template
		Dim template = File.ReadAllText("invoice-template.html")

		' Simple string replacement for data
		Dim html = template.Replace("{{InvoiceNumber}}", data.InvoiceNumber).Replace("{{Date}}", data.Date.ToString("yyyy-MM-dd")).Replace("{{CustomerName}}", data.CustomerName).Replace("{{Total}}", data.Total.ToString("C"))

		' Convert to PDF
		Return _converter.ConvertHtml(html, "")
	End Function
End Class
$vbLabelText   $csharpLabel

Zaawansowane wzorce implementacji i najlepsze praktyki

Optymalizacja wydajności w środowisku produkcyjnym

Obie biblioteki działają najlepiej przy odpowiedniej konfiguracji i wzorcach użytkowania:

Optymalizacja wydajności IronPDF

public class OptimizedPdfService
{
    private readonly ChromePdfRenderer _renderer;
    private readonly SemaphoreSlim _semaphore;

    public OptimizedPdfService(int maxConcurrency = 4)
    {
        _semaphore = new SemaphoreSlim(maxConcurrency);

        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                // Optimize for performance
                EnableJavaScript = false, // Only if not needed
                RenderDelay = 0,
                DPI = 150, // Balance quality vs speed
                CssMediaType = PdfCssMediaType.Screen,
                Timeout = 30,

                // Memory optimization
                OptimizeForLowMemory = true
            }
        };

        // Enable connection pooling
        Installation.ChromeGpuMode = ChromeGpuModes.Disabled;
        Installation.LinuxAndDockerDependenciesAutoConfig = false;
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _semaphore.WaitAsync();
        try
        {
            var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

            // Optimize file size
            pdf.CompressImages(85);
            pdf.RemoveUnusedResources();

            return pdf.BinaryData;
        }
        finally
        {
            _semaphore.Release();
        }
    }
}
public class OptimizedPdfService
{
    private readonly ChromePdfRenderer _renderer;
    private readonly SemaphoreSlim _semaphore;

    public OptimizedPdfService(int maxConcurrency = 4)
    {
        _semaphore = new SemaphoreSlim(maxConcurrency);

        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                // Optimize for performance
                EnableJavaScript = false, // Only if not needed
                RenderDelay = 0,
                DPI = 150, // Balance quality vs speed
                CssMediaType = PdfCssMediaType.Screen,
                Timeout = 30,

                // Memory optimization
                OptimizeForLowMemory = true
            }
        };

        // Enable connection pooling
        Installation.ChromeGpuMode = ChromeGpuModes.Disabled;
        Installation.LinuxAndDockerDependenciesAutoConfig = false;
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _semaphore.WaitAsync();
        try
        {
            var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

            // Optimize file size
            pdf.CompressImages(85);
            pdf.RemoveUnusedResources();

            return pdf.BinaryData;
        }
        finally
        {
            _semaphore.Release();
        }
    }
}
Public Class OptimizedPdfService
	Private ReadOnly _renderer As ChromePdfRenderer
	Private ReadOnly _semaphore As SemaphoreSlim

	Public Sub New(Optional ByVal maxConcurrency As Integer = 4)
		_semaphore = New SemaphoreSlim(maxConcurrency)

		_renderer = New ChromePdfRenderer With {
			.RenderingOptions = New ChromePdfRenderOptions With {
				.EnableJavaScript = False,
				.RenderDelay = 0,
				.DPI = 150,
				.CssMediaType = PdfCssMediaType.Screen,
				.Timeout = 30,
				.OptimizeForLowMemory = True
			}
		}

		' Enable connection pooling
		Installation.ChromeGpuMode = ChromeGpuModes.Disabled
		Installation.LinuxAndDockerDependenciesAutoConfig = False
	End Sub

	Public Async Function GeneratePdfAsync(ByVal html As String) As Task(Of Byte())
		Await _semaphore.WaitAsync()
		Try
			Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)

			' Optimize file size
			pdf.CompressImages(85)
			pdf.RemoveUnusedResources()

			Return pdf.BinaryData
		Finally
			_semaphore.Release()
		End Try
	End Function
End Class
$vbLabelText   $csharpLabel

Wzorce wydajności EvoPdf

public class EvoPdfOptimizedService
{
    private readonly ObjectPool<HtmlToPdfConverter> _converterPool;

    public EvoPdfOptimizedService()
    {
        // Create object pool for converter reuse
        _converterPool = new DefaultObjectPool<HtmlToPdfConverter>(
            new ConverterPoolPolicy(), 
            Environment.ProcessorCount * 2);
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        var converter = _converterPool.Get();
        try
        {
            // Configure for speed
            converter.ConversionDelay = 0;
            converter.JavaScriptEnabled = false;

            // Use async pattern
            return await Task.Run(() => converter.ConvertHtml(html, ""));
        }
        finally
        {
            _converterPool.Return(converter);
        }
    }

    private class ConverterPoolPolicy : IPooledObjectPolicy<HtmlToPdfConverter>
    {
        public HtmlToPdfConverter Create()
        {
            return new HtmlToPdfConverter
            {
                LicenseKey = "your-license-key"
            };
        }

        public bool Return(HtmlToPdfConverter obj)
        {
            // Reset to default state
            obj.ConversionDelay = 2;
            return true;
        }
    }
}
public class EvoPdfOptimizedService
{
    private readonly ObjectPool<HtmlToPdfConverter> _converterPool;

    public EvoPdfOptimizedService()
    {
        // Create object pool for converter reuse
        _converterPool = new DefaultObjectPool<HtmlToPdfConverter>(
            new ConverterPoolPolicy(), 
            Environment.ProcessorCount * 2);
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        var converter = _converterPool.Get();
        try
        {
            // Configure for speed
            converter.ConversionDelay = 0;
            converter.JavaScriptEnabled = false;

            // Use async pattern
            return await Task.Run(() => converter.ConvertHtml(html, ""));
        }
        finally
        {
            _converterPool.Return(converter);
        }
    }

    private class ConverterPoolPolicy : IPooledObjectPolicy<HtmlToPdfConverter>
    {
        public HtmlToPdfConverter Create()
        {
            return new HtmlToPdfConverter
            {
                LicenseKey = "your-license-key"
            };
        }

        public bool Return(HtmlToPdfConverter obj)
        {
            // Reset to default state
            obj.ConversionDelay = 2;
            return true;
        }
    }
}
Public Class EvoPdfOptimizedService
	Private ReadOnly _converterPool As ObjectPool(Of HtmlToPdfConverter)

	Public Sub New()
		' Create object pool for converter reuse
		_converterPool = New DefaultObjectPool(Of HtmlToPdfConverter)(New ConverterPoolPolicy(), Environment.ProcessorCount * 2)
	End Sub

	Public Async Function GeneratePdfAsync(ByVal html As String) As Task(Of Byte())
		Dim converter = _converterPool.Get()
		Try
			' Configure for speed
			converter.ConversionDelay = 0
			converter.JavaScriptEnabled = False

			' Use async pattern
			Return Await Task.Run(Function() converter.ConvertHtml(html, ""))
		Finally
			_converterPool.Return(converter)
		End Try
	End Function

	Private Class ConverterPoolPolicy
		Implements IPooledObjectPolicy(Of HtmlToPdfConverter)

		Public Function Create() As HtmlToPdfConverter
			Return New HtmlToPdfConverter With {.LicenseKey = "your-license-key"}
		End Function

		Public Function [Return](ByVal obj As HtmlToPdfConverter) As Boolean
			' Reset to default state
			obj.ConversionDelay = 2
			Return True
		End Function
	End Class
End Class
$vbLabelText   $csharpLabel

Obsługa błędów i debugowanie

Solidna obsługa błędów ma kluczowe znaczenie dla aplikacji produkcyjnych:

Obsługa błędów w IronPDF

public class RobustPdfGenerator
{
    private readonly ILogger<RobustPdfGenerator> _logger;
    private readonly ChromePdfRenderer _renderer;

    public async Task<Result<byte[]>> TryGeneratePdfAsync(string html)
    {
        try
        {
            // Enable detailed logging
            IronPdf.Logging.Logger.EnableDebugging = true;
            IronPdf.Logging.Logger.LogFilePath = "ironpdf.log";
            IronPdf.Logging.Logger.LoggingLevel = LoggingLevels.All;

            var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

            // Validate output
            if (pdf.PageCount == 0)
            {
                return Result<byte[]>.Failure("Generated PDF has no pages");
            }

            return Result<byte[]>.Success(pdf.BinaryData);
        }
        catch (IronPdf.Exceptions.IronPdfRenderException ex)
        {
            _logger.LogError(ex, "Rendering failed: {Message}", ex.Message);

            // Attempt fallback with simpler settings
            return await FallbackRender(html);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unexpected error in PDF generation");
            return Result<byte[]>.Failure($"PDF generation failed: {ex.Message}");
        }
    }

    private async Task<Result<byte[]>> FallbackRender(string html)
    {
        var fallbackRenderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                EnableJavaScript = false,
                DPI = 96,
                Timeout = 60
            }
        };

        try
        {
            var pdf = await fallbackRenderer.RenderHtmlAsPdfAsync(html);
            return Result<byte[]>.Success(pdf.BinaryData);
        }
        catch (Exception ex)
        {
            return Result<byte[]>.Failure($"Fallback render failed: {ex.Message}");
        }
    }
}
public class RobustPdfGenerator
{
    private readonly ILogger<RobustPdfGenerator> _logger;
    private readonly ChromePdfRenderer _renderer;

    public async Task<Result<byte[]>> TryGeneratePdfAsync(string html)
    {
        try
        {
            // Enable detailed logging
            IronPdf.Logging.Logger.EnableDebugging = true;
            IronPdf.Logging.Logger.LogFilePath = "ironpdf.log";
            IronPdf.Logging.Logger.LoggingLevel = LoggingLevels.All;

            var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

            // Validate output
            if (pdf.PageCount == 0)
            {
                return Result<byte[]>.Failure("Generated PDF has no pages");
            }

            return Result<byte[]>.Success(pdf.BinaryData);
        }
        catch (IronPdf.Exceptions.IronPdfRenderException ex)
        {
            _logger.LogError(ex, "Rendering failed: {Message}", ex.Message);

            // Attempt fallback with simpler settings
            return await FallbackRender(html);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unexpected error in PDF generation");
            return Result<byte[]>.Failure($"PDF generation failed: {ex.Message}");
        }
    }

    private async Task<Result<byte[]>> FallbackRender(string html)
    {
        var fallbackRenderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                EnableJavaScript = false,
                DPI = 96,
                Timeout = 60
            }
        };

        try
        {
            var pdf = await fallbackRenderer.RenderHtmlAsPdfAsync(html);
            return Result<byte[]>.Success(pdf.BinaryData);
        }
        catch (Exception ex)
        {
            return Result<byte[]>.Failure($"Fallback render failed: {ex.Message}");
        }
    }
}
Public Class RobustPdfGenerator
	Private ReadOnly _logger As ILogger(Of RobustPdfGenerator)
	Private ReadOnly _renderer As ChromePdfRenderer

	Public Async Function TryGeneratePdfAsync(ByVal html As String) As Task(Of Result(Of Byte()))
		Try
			' Enable detailed logging
			IronPdf.Logging.Logger.EnableDebugging = True
			IronPdf.Logging.Logger.LogFilePath = "ironpdf.log"
			IronPdf.Logging.Logger.LoggingLevel = LoggingLevels.All

			Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)

			' Validate output
			If pdf.PageCount = 0 Then
				Return Result(Of Byte()).Failure("Generated PDF has no pages")
			End If

			Return Result(Of Byte()).Success(pdf.BinaryData)
		Catch ex As IronPdf.Exceptions.IronPdfRenderException
			_logger.LogError(ex, "Rendering failed: {Message}", ex.Message)

			' Attempt fallback with simpler settings
			Return Await FallbackRender(html)
		Catch ex As Exception
			_logger.LogError(ex, "Unexpected error in PDF generation")
			Return Result(Of Byte()).Failure($"PDF generation failed: {ex.Message}")
		End Try
	End Function

	Private Async Function FallbackRender(ByVal html As String) As Task(Of Result(Of Byte()))
		Dim fallbackRenderer = New ChromePdfRenderer With {
			.RenderingOptions = New ChromePdfRenderOptions With {
				.EnableJavaScript = False,
				.DPI = 96,
				.Timeout = 60
			}
		}

		Try
			Dim pdf = Await fallbackRenderer.RenderHtmlAsPdfAsync(html)
			Return Result(Of Byte()).Success(pdf.BinaryData)
		Catch ex As Exception
			Return Result(Of Byte()).Failure($"Fallback render failed: {ex.Message}")
		End Try
	End Function
End Class
$vbLabelText   $csharpLabel

Przykłady wdrożeń w konkretnych branżach

Usługi finansowe: zgodność z przepisami

Instytucje finansowe wymagają określonych funkcji w celu zapewnienia zgodności z przepisami:

public class FinancialStatementGenerator
{
    public async Task<byte[]> GenerateQuarterlyReport(FinancialData data)
    {
        var renderer = new ChromePdfRenderer();

        // Generate report with charts and tables
        var html = await BuildFinancialReportHtml(data);
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Add compliance watermark
        pdf.ApplyWatermark(@"
            <div style='text-align: center; color: rgba(0,0,0,0.1); font-size: 120px;
                        transform: rotate(-45deg); font-family: Arial;'>
                DRAFT
            </div>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center);

        // Embed audit information
        pdf.MetaData.Author = "Financial Reporting System";
        pdf.MetaData.Keywords = "Quarterly Report, SOX Compliant";
        pdf.MetaData.CustomProperties.Add("ReportPeriod", data.Quarter);
        pdf.MetaData.CustomProperties.Add("GeneratedBy", Environment.UserName);
        pdf.MetaData.CustomProperties.Add("Timestamp", DateTime.UtcNow.ToString("O"));

        // Apply tamper-evident signature
        var cert = new X509Certificate2("financial-cert.pfx", "password");
        var signature = new PdfSignature(cert)
        {
            SigningReason = "Financial Report Certification",
            SigningLocation = "Corporate Finance Department",
            IsVisible = true,
            SignatureImage = new PdfSignatureImage("cfo-signature.png")
        };

        pdf.Sign(signature);

        // Lock document from editing
        pdf.SecuritySettings = new SecuritySettings
        {
            AllowModifyDocument = false,
            AllowCopy = true,
            AllowPrint = true,
            EncryptionLevel = EncryptionLevel.AES256Bit
        };

        return pdf.BinaryData;
    }
}
public class FinancialStatementGenerator
{
    public async Task<byte[]> GenerateQuarterlyReport(FinancialData data)
    {
        var renderer = new ChromePdfRenderer();

        // Generate report with charts and tables
        var html = await BuildFinancialReportHtml(data);
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Add compliance watermark
        pdf.ApplyWatermark(@"
            <div style='text-align: center; color: rgba(0,0,0,0.1); font-size: 120px;
                        transform: rotate(-45deg); font-family: Arial;'>
                DRAFT
            </div>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center);

        // Embed audit information
        pdf.MetaData.Author = "Financial Reporting System";
        pdf.MetaData.Keywords = "Quarterly Report, SOX Compliant";
        pdf.MetaData.CustomProperties.Add("ReportPeriod", data.Quarter);
        pdf.MetaData.CustomProperties.Add("GeneratedBy", Environment.UserName);
        pdf.MetaData.CustomProperties.Add("Timestamp", DateTime.UtcNow.ToString("O"));

        // Apply tamper-evident signature
        var cert = new X509Certificate2("financial-cert.pfx", "password");
        var signature = new PdfSignature(cert)
        {
            SigningReason = "Financial Report Certification",
            SigningLocation = "Corporate Finance Department",
            IsVisible = true,
            SignatureImage = new PdfSignatureImage("cfo-signature.png")
        };

        pdf.Sign(signature);

        // Lock document from editing
        pdf.SecuritySettings = new SecuritySettings
        {
            AllowModifyDocument = false,
            AllowCopy = true,
            AllowPrint = true,
            EncryptionLevel = EncryptionLevel.AES256Bit
        };

        return pdf.BinaryData;
    }
}
Public Class FinancialStatementGenerator
	Public Async Function GenerateQuarterlyReport(ByVal data As FinancialData) As Task(Of Byte())
		Dim renderer = New ChromePdfRenderer()

		' Generate report with charts and tables
		Dim html = Await BuildFinancialReportHtml(data)
		Dim pdf = renderer.RenderHtmlAsPdf(html)

		' Add compliance watermark
		pdf.ApplyWatermark("
            <div style='text-align: center; color: rgba(0,0,0,0.1); font-size: 120px;
                        transform: rotate(-45deg); font-family: Arial;'>
                DRAFT
            </div>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center)

		' Embed audit information
		pdf.MetaData.Author = "Financial Reporting System"
		pdf.MetaData.Keywords = "Quarterly Report, SOX Compliant"
		pdf.MetaData.CustomProperties.Add("ReportPeriod", data.Quarter)
		pdf.MetaData.CustomProperties.Add("GeneratedBy", Environment.UserName)
		pdf.MetaData.CustomProperties.Add("Timestamp", DateTime.UtcNow.ToString("O"))

		' Apply tamper-evident signature
		Dim cert = New X509Certificate2("financial-cert.pfx", "password")
		Dim signature = New PdfSignature(cert) With {
			.SigningReason = "Financial Report Certification",
			.SigningLocation = "Corporate Finance Department",
			.IsVisible = True,
			.SignatureImage = New PdfSignatureImage("cfo-signature.png")
		}

		pdf.Sign(signature)

		' Lock document from editing
		pdf.SecuritySettings = New SecuritySettings With {
			.AllowModifyDocument = False,
			.AllowCopy = True,
			.AllowPrint = True,
			.EncryptionLevel = EncryptionLevel.AES256Bit
		}

		Return pdf.BinaryData
	End Function
End Class
$vbLabelText   $csharpLabel

E-commerce: dynamiczne generowanie faktur

Platformy e-commerce potrzebują szybkiego i niezawodnego generowania faktur:

public class EcommerceInvoiceService
{
    private readonly ChromePdfRenderer _renderer;

    public EcommerceInvoiceService()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                MarginTop = 10,
                MarginBottom = 10,
                PaperSize = PdfPaperSize.A4,
                DPI = 200 // High quality for barcodes
            }
        };
    }

    public async Task<byte[]> GenerateInvoice(Order order)
    {
        // Build invoice HTML with order details
        var html = $@"
        <html>
        <head>
            <style>
                @page {{size: A4; margin: 0;}}
                body {{font-family: Arial, sans-serif;}}
                .invoice-header {{background: #f0f0f0; padding: 20px;}}
                .barcode {{text-align: center; margin: 20px 0;}}
                table {{width: 100%; border-collapse: collapse;}}
                th, td {{padding: 10px; border-bottom: 1px solid #ddd;}}
            </style>
        </head>
        <body>
            <div class='invoice-header'>
                <h1>Invoice #{order.InvoiceNumber}</h1>
                <p>Date: {order.Date:yyyy-MM-dd}</p>
            </div>

            <div class='barcode'>
                <img src='data:image/png;base64,{GenerateBarcode(order.InvoiceNumber)}' />
            </div>

            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                    <th>Total</th>
                </tr>
                {string.Join("", order.Items.Select(item => $@"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                    <td>${item.Total:F2}</td>
                </tr>"))}
                <tr>
                    <td colspan='3'><strong>Total</strong></td>
                    <td><strong>${order.Total:F2}</strong></td>
                </tr>
            </table>

            <div class='footer'>
                <p>Thank you for your business!</p>
                <p>Return policy and terms at: www.example.com/terms</p>
            </div>
        </body>
        </html>";

        var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

        // Add QR code for mobile payment verification
        var qrStamper = new ImageStamper($"https://api.qrserver.com/v1/create-qr-code/?data={order.PaymentId}")
        {
            HorizontalAlignment = HorizontalAlignment.Right,
            VerticalAlignment = VerticalAlignment.Bottom,
            Width = 100,
            Height = 100
        };

        pdf.ApplyStamp(qrStamper);

        return pdf.BinaryData;
    }
}
public class EcommerceInvoiceService
{
    private readonly ChromePdfRenderer _renderer;

    public EcommerceInvoiceService()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                MarginTop = 10,
                MarginBottom = 10,
                PaperSize = PdfPaperSize.A4,
                DPI = 200 // High quality for barcodes
            }
        };
    }

    public async Task<byte[]> GenerateInvoice(Order order)
    {
        // Build invoice HTML with order details
        var html = $@"
        <html>
        <head>
            <style>
                @page {{size: A4; margin: 0;}}
                body {{font-family: Arial, sans-serif;}}
                .invoice-header {{background: #f0f0f0; padding: 20px;}}
                .barcode {{text-align: center; margin: 20px 0;}}
                table {{width: 100%; border-collapse: collapse;}}
                th, td {{padding: 10px; border-bottom: 1px solid #ddd;}}
            </style>
        </head>
        <body>
            <div class='invoice-header'>
                <h1>Invoice #{order.InvoiceNumber}</h1>
                <p>Date: {order.Date:yyyy-MM-dd}</p>
            </div>

            <div class='barcode'>
                <img src='data:image/png;base64,{GenerateBarcode(order.InvoiceNumber)}' />
            </div>

            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                    <th>Total</th>
                </tr>
                {string.Join("", order.Items.Select(item => $@"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                    <td>${item.Total:F2}</td>
                </tr>"))}
                <tr>
                    <td colspan='3'><strong>Total</strong></td>
                    <td><strong>${order.Total:F2}</strong></td>
                </tr>
            </table>

            <div class='footer'>
                <p>Thank you for your business!</p>
                <p>Return policy and terms at: www.example.com/terms</p>
            </div>
        </body>
        </html>";

        var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

        // Add QR code for mobile payment verification
        var qrStamper = new ImageStamper($"https://api.qrserver.com/v1/create-qr-code/?data={order.PaymentId}")
        {
            HorizontalAlignment = HorizontalAlignment.Right,
            VerticalAlignment = VerticalAlignment.Bottom,
            Width = 100,
            Height = 100
        };

        pdf.ApplyStamp(qrStamper);

        return pdf.BinaryData;
    }
}
Imports System.Threading.Tasks

Public Class EcommerceInvoiceService
    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer With {
            .RenderingOptions = New ChromePdfRenderOptions With {
                .MarginTop = 10,
                .MarginBottom = 10,
                .PaperSize = PdfPaperSize.A4,
                .DPI = 200 ' High quality for barcodes
            }
        }
    End Sub

    Public Async Function GenerateInvoice(order As Order) As Task(Of Byte())
        ' Build invoice HTML with order details
        Dim html As String = $"
        <html>
        <head>
            <style>
                @page {{size: A4; margin: 0;}}
                body {{font-family: Arial, sans-serif;}}
                .invoice-header {{background: #f0f0f0; padding: 20px;}}
                .barcode {{text-align: center; margin: 20px 0;}}
                table {{width: 100%; border-collapse: collapse;}}
                th, td {{padding: 10px; border-bottom: 1px solid #ddd;}}
            </style>
        </head>
        <body>
            <div class='invoice-header'>
                <h1>Invoice #{order.InvoiceNumber}</h1>
                <p>Date: {order.Date:yyyy-MM-dd}</p>
            </div>

            <div class='barcode'>
                <img src='data:image/png;base64,{GenerateBarcode(order.InvoiceNumber)}' />
            </div>

            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                    <th>Total</th>
                </tr>
                {String.Join("", order.Items.Select(Function(item) $"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                    <td>${item.Total:F2}</td>
                </tr>"))}
                <tr>
                    <td colspan='3'><strong>Total</strong></td>
                    <td><strong>${order.Total:F2}</strong></td>
                </tr>
            </table>

            <div class='footer'>
                <p>Thank you for your business!</p>
                <p>Return policy and terms at: www.example.com/terms</p>
            </div>
        </body>
        </html>"

        Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)

        ' Add QR code for mobile payment verification
        Dim qrStamper = New ImageStamper($"https://api.qrserver.com/v1/create-qr-code/?data={order.PaymentId}") With {
            .HorizontalAlignment = HorizontalAlignment.Right,
            .VerticalAlignment = VerticalAlignment.Bottom,
            .Width = 100,
            .Height = 100
        }

        pdf.ApplyStamp(qrStamper)

        Return pdf.BinaryData
    End Function
End Class
$vbLabelText   $csharpLabel

Strategie migracji: przechodzenie między bibliotekami

Jeśli rozważasz zmianę biblioteki, oto podejście do migracji:

Migracja z EvoPdf do IronPDF

// EvoPdf pattern
HtmlToPdfConverter evoPdfConverter = new HtmlToPdfConverter();
evoPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
byte[] pdfBytes = evoPdfConverter.ConvertUrl(url);

// Equivalent IronPDF pattern
var ironPdfRenderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        PaperSize = PdfPaperSize.A4
    }
};
var pdf = ironPdfRenderer.RenderUrlAsPdf(url);
byte[] pdfBytes = pdf.BinaryData;

// Migration wrapper for gradual transition
public interface IPdfConverter
{
    byte[] ConvertHtmlToPdf(string html);
    byte[] ConvertUrlToPdf(string url);
}

public class IronPdfAdapter : IPdfConverter
{
    private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

    public byte[] ConvertHtmlToPdf(string html)
    {
        return _renderer.RenderHtmlAsPdf(html).BinaryData;
    }

    public byte[] ConvertUrlToPdf(string url)
    {
        return _renderer.RenderUrlAsPdf(url).BinaryData;
    }
}

public class EvoPdfAdapter : IPdfConverter
{
    private readonly HtmlToPdfConverter _converter = new HtmlToPdfConverter();

    public byte[] ConvertHtmlToPdf(string html)
    {
        return _converter.ConvertHtml(html, "");
    }

    public byte[] ConvertUrlToPdf(string url)
    {
        return _converter.ConvertUrl(url);
    }
}
// EvoPdf pattern
HtmlToPdfConverter evoPdfConverter = new HtmlToPdfConverter();
evoPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
byte[] pdfBytes = evoPdfConverter.ConvertUrl(url);

// Equivalent IronPDF pattern
var ironPdfRenderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        PaperSize = PdfPaperSize.A4
    }
};
var pdf = ironPdfRenderer.RenderUrlAsPdf(url);
byte[] pdfBytes = pdf.BinaryData;

// Migration wrapper for gradual transition
public interface IPdfConverter
{
    byte[] ConvertHtmlToPdf(string html);
    byte[] ConvertUrlToPdf(string url);
}

public class IronPdfAdapter : IPdfConverter
{
    private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

    public byte[] ConvertHtmlToPdf(string html)
    {
        return _renderer.RenderHtmlAsPdf(html).BinaryData;
    }

    public byte[] ConvertUrlToPdf(string url)
    {
        return _renderer.RenderUrlAsPdf(url).BinaryData;
    }
}

public class EvoPdfAdapter : IPdfConverter
{
    private readonly HtmlToPdfConverter _converter = new HtmlToPdfConverter();

    public byte[] ConvertHtmlToPdf(string html)
    {
        return _converter.ConvertHtml(html, "");
    }

    public byte[] ConvertUrlToPdf(string url)
    {
        return _converter.ConvertUrl(url);
    }
}
' EvoPdf pattern
Dim evoPdfConverter As New HtmlToPdfConverter()
evoPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4
Dim pdfBytes() As Byte = evoPdfConverter.ConvertUrl(url)

' Equivalent IronPDF pattern
Dim ironPdfRenderer = New ChromePdfRenderer With {
	.RenderingOptions = New ChromePdfRenderOptions With {.PaperSize = PdfPaperSize.A4}
}
Dim pdf = ironPdfRenderer.RenderUrlAsPdf(url)
Dim pdfBytes() As Byte = pdf.BinaryData

' Migration wrapper for gradual transition
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public interface IPdfConverter
'{
'	byte[] ConvertHtmlToPdf(string html);
'	byte[] ConvertUrlToPdf(string url);
'}

'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public class IronPdfAdapter : IPdfConverter
'{
'	private readonly ChromePdfRenderer _renderer = New ChromePdfRenderer();
'
'	public byte[] ConvertHtmlToPdf(string html)
'	{
'		Return _renderer.RenderHtmlAsPdf(html).BinaryData;
'	}
'
'	public byte[] ConvertUrlToPdf(string url)
'	{
'		Return _renderer.RenderUrlAsPdf(url).BinaryData;
'	}
'}

'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public class EvoPdfAdapter : IPdfConverter
'{
'	private readonly HtmlToPdfConverter _converter = New HtmlToPdfConverter();
'
'	public byte[] ConvertHtmlToPdf(string html)
'	{
'		Return _converter.ConvertHtml(html, "");
'	}
'
'	public byte[] ConvertUrlToPdf(string url)
'	{
'		Return _converter.ConvertUrl(url);
'	}
'}
$vbLabelText   $csharpLabel

Wniosek: Dokonaj właściwego wyboru dla swojego projektu

Zarówno IronPDF, jak i EvoPdf odgrywają ważną rolę w ekosystemie bibliotek PDF dla platformy .NET, ale są przeznaczone do różnych zastosowań i opierają się na różnych filozofiach programowania.

Wybierz IronPDF, jeśli potrzebujesz:

  • Obsługa nowoczesnych standardów internetowych (CSS3, frameworki JavaScript)
  • Kompleksowa obsługa plików PDF wykraczająca poza samo generowanie
  • Funkcje bezpieczeństwa dla Enterprise i narzędzia zapewniające zgodność z przepisami
  • Elastyczność wdrażania na wielu platformach
  • Obszerna dokumentacja i bezpośrednie wsparcie inżynierów
  • Integracja z innymi narzędziami do przetwarzania dokumentów

Wybierz EvoPdf, jeśli potrzebujesz:

  • Prosta konwersja HTML do PDF przy niższych kosztach
  • Podstawowe generowanie plików PDF dla prostych dokumentów
  • Nieograniczona liczba licencji deweloperskich dla dużych zespołów
  • Szybsze przetwarzanie prostych treści HTML
  • Środowisko wdrożeniowe oparte na systemie Windows

Ostateczna decyzja zależy od konkretnych wymagań, ograniczeń budżetowych oraz długoterminowych potrzeb w zakresie skalowalności. Dla większości nowoczesnych aplikacji wymagających solidnych możliwości PDF, kompleksowy zestaw funkcji IronPDF i silnik renderujący oparty na Chrome czyni go silną inwestycją. Jednak EvoPdf pozostaje realną opcją w prostszych przypadkach użycia, gdzie głównym czynnikiem jest koszt.

Rozważ rozpoczęcie od 30-dniowego okresu próbnego IronPDF, aby ocenić jego możliwości w konkretnym przypadku użycia. Wersja próbna daje dostęp do funkcji IronPDF, pozwalając podjąć świadomą decyzję na podstawie faktycznej wydajności w twoim środowisku.

Należy pamiętać, że rzeczywisty koszt biblioteki PDF wykracza poza cenę licencji — należy uwzględnić czas rozwoju, koszty utrzymania oraz potencjalną potrzebę wprowadzenia dodatkowych funkcji w miarę rozwoju aplikacji. Wybierz bibliotekę, która nie tylko spełnia Twoje obecne potrzeby, ale także może skalować się wraz z przyszłymi wymaganiami.

Zwróć uwagęEvoPdf jest zastrzeżonym znakiem towarowym odpowiedniego właściciela. Ta strona nie jest powiązana z EvoPdf, nie jest przez nią promowana ani sponsorowana. 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.

Często Zadawane Pytania

Jak mogę przekonwertować HTML na PDF w języku C# przy użyciu biblioteki .NET?

Możesz użyć metody RenderHtmlAsPdf biblioteki IronPDF do konwersji ciągów HTML na pliki PDF. Możesz również konwertować pliki HTML na pliki PDF za pomocą metody RenderHtmlFileAsPdf.

Jaka jest najlepsza biblioteka .NET do obsługi plików PDF, umożliwiająca pracę ze złożonymi kodami JavaScript i CSS?

IronPDF to najlepszy wybór do obsługi złożonego kodu JavaScript i CSS, ponieważ wykorzystuje pełny silnik renderujący Chrome V8, zapewniając ponad 98% wierności przeglądarki oraz obsługę nowoczesnych frameworków, takich jak React i Angular.

Która biblioteka .NET do obsługi plików PDF oferuje lepszą obsługę wielu platform?

IronPDF oferuje doskonałą obsługę wielu platform dzięki natywnej kompatybilności z systemami Windows, Linux, macOS oraz kontenerami Docker, co pozwala na wdrożenie bez konieczności konfiguracji.

Jakie są kluczowe funkcje IronPDF w zakresie bezpieczeństwa i zgodności z przepisami?

IronPDF zapewnia kompleksowe funkcje bezpieczeństwa, w tym szyfrowanie AES-256, ponad 15 szczegółowych ustawień uprawnień, wizualne podpisy cyfrowe oraz prawdziwą redakcję treści przy użyciu metody RedactTextOnAllPages().

Jak efektywnie przetwarzać pliki PDF w trybie wsadowym w środowisku .NET?

IronPDF wyróżnia się w przetwarzaniu plików PDF w trybie wsadowym, oferując natywną optymalizację async/await oraz lepsze zarządzanie pamięcią, dzięki czemu nadaje się do wydajnego przetwarzania dużych dokumentów.

Która biblioteka zapewnia lepsze wsparcie i dokumentację dla programistów?

IronPDF zapewnia szerokie wsparcie i dokumentację, w tym pomoc techniczną dostępną 24 godziny na dobę przez 5 dni w tygodniu, obszerną dokumentację API, ponad 100 przykładów kodu oraz samouczki wideo, co znacznie skraca czas programowania.

Czy mogę konwertować pliki DOCX na PDF za pomocą biblioteki .NET?

Tak, IronPDF zawiera wbudowaną funkcję konwersji plików DOCX do formatu PDF za pośrednictwem klasy DocxToPdfRenderer, umożliwiającą konwersję dokumentów WORD przy zachowaniu formatowania.

Jakie są zalety korzystania z IronPDF w nowoczesnych aplikacjach internetowych?

IronPDF idealnie nadaje się do nowoczesnych aplikacji internetowych dzięki silnikowi renderowania opartemu na przeglądarce Chrome, wszechstronnym funkcjom manipulacji plikami PDF oraz kompatybilności międzyplatformowej, co sprawia, że nadaje się do dynamicznego generowania treści i złożonego przetwarzania dokumentów.

W jaki sposób IronPDF radzi sobie z redagowaniem plików PDF w celu spełnienia wymogów zgodności?

IronPDF oferuje kompleksowe funkcje redagowania, w tym usuwanie treści oparte na wyrażeniach regularnych oraz redagowanie oparte na OCR, zapewniając zgodność z przepisami dotyczącymi prywatności, takimi jak RODO i HIPAA.

Dlaczego IronPDF jest dobrym wyborem dla platform SaaS i e-commerce?

IronPDF doskonale nadaje się do platform SaaS i e-commerce dzięki możliwości generowania dynamicznych faktur, obsłudze podpisów cyfrowych oraz płynnej integracji z nowoczesnymi technologiami internetowymi.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie