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. Gembox.Pdf
PORóWNANIA PRODUKTóW

IronPDF vs PDFTron (Apryse): Kompleksowe porównanie bibliotek PDF C# na 2025 rok

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

Podczas tworzenia aplikacji .NET, które wymagają generowania i edycji plików PDF, wybór odpowiedniej biblioteki C# do obsługi plików PDF może znacząco wpłynąć na sukces projektu. W tym kompleksowym porównaniu przeanalizowano IronPDF i GemBox.Pdf, dwie czołowe biblioteki PDF dla platformy .NET, aby pomóc programistom w podjęciu świadomej decyzji w oparciu o funkcje, wydajność, ceny i rzeczywiste przypadki użycia.

Szybki przegląd porównawczy

Przegląd porównania produktów
Porównanie funkcji IronPDF for .NET i GemBox.Pdf dla programowania w .NET
Kategoria Funkcja/Aspekt IronPDF GemBox.Pdf Kluczowa zaleta
Podstawowa architektura Filozofia projektowania HTML-first, renderowanie w przeglądarce Chrome Manipulacja plikami PDF Zależy od kontekstu
Złożoność API Proste metody jak RenderHtmlAsPdf() Obiekty PDF niskiego poziomu IronPDF: Szybsze tworzenie
Krzywa uczenia się Zazwyczaj 1–2 dni 3-5 dni typowo IronPDF: Szybsze przyswajanie
Obsługa platform Wielopłatformowe Windows, Linux, macOS, Docker Windows, Linux, macOS, Android, iOS GemBox: Obsługa urządzeń mobilnych
Wersje .NET .NET 10, 9, 8, 7, 6, 5, Core 3.1+, Framework 4.6.2+ .NET 6, .NET Standard 2.0, Framework 3.5+ IronPDF: Najnowsza obsługa platformy .NET
Platformy chmurowe Zoptymalizowane pod kątem Azure/AWS Standardowa obsługa chmury IronPDF: Gotowy do pracy w chmurze
HTML do PDF Silnik renderujący Pełny silnik Chrome V8 Silnik oparty na Chromium Obie: Renderowanie Chromium
Obsługa CSS3/HTML5 Pełne wsparcie Wsparcie HTML5/CSS3 Obie: Nowoczesne standardy webowe
Wykonanie JavaScript Pełna obsługa JavaScript Wsparcie egzekucji JavaScript Obie: Treści dynamiczne
Szybkość renderowania ~125 ms (typowo) Renderowanie oparte na Chromium IronPDF: Dokumentowany czas renderowania
Doświadczenie programisty Przykłady kodu Ponad 100 gotowych do uruchomienia przykładów Dostępnych jest ponad 100 przykładów Oba: Obszerne zasoby
Dokumentacja Samouczki, instrukcje, filmy Dokumentacja API IronPDF: Wiele ścieżek nauki
Manipulacja treścią Łączenie/dzielenie plików PDF Wbudowane metody Wbudowane metody Oba: Standardowe funkcje
Wyodrębnianie tekstu Obsługa Unicode, integracja OCR Obsługa Unicode, wbudowany OCR GemBox: Wbudowany moduł OCR
Obsługa formularzy Formularze HTML do formularzy PDF Tworzenie, wypełnianie i spłaszczanie formularzy Zależy od kontekstu
Wskaźniki wydajności Wykorzystanie pamięci Zazwyczaj poniżej 10 MB Niewielkie obciążenie pamięci Oba: Efektywne
Obsługa wątków Zoptymalizowane pod kątem natywnego async/await Operacje bezpieczne dla wątków IronPDF: Lepsze wsparcie asynchroniczne
Security & Encryption Poziomy szyfrowania AES-256, niestandardowe procedury obsługi Standard AES-256 Oba: Standard branżowy
Podpisy cyfrowe Zintegrowane, wizualne podpisy Obsługa podpisu cyfrowego Oba: Obsługa podpisów
Licensing & Pricing Poziom początkowy Lite: $999 (1 deweloper, 1 projekt) Single Dev: `$890` (1 deweloper, nieograniczona liczba projektów) IronPDF: Niższy koszt wejścia
Redystrybucja +$1,999 bez opłat licencyjnych W cenie, nieograniczona liczba wdrożeń GemBox: Lepsze warunki wdrożenia
Opcja Suite Iron Suite: $2,998 (9 products) GemBox Bundle: `$2,200` (6 products, 1 dev) IronPDF: lepszy zestaw funkcji
Wsparcie Wsparcie techniczne w cenie Tak, wsparcie inżynierskie 24/5 Tak, 1 rok profesjonalnego wsparcia Oba: Dobre wsparcie
Czas odpowiedzi 24-48 godzin typowo W ciągu 1 dnia roboczego Oba: Szybka odpowiedź
Najlepsze dla Przykłady zastosowań HTML do PDF, aplikacje internetowe, raporty Manipulacja plikami PDF, formularze, OCR Zależy od kontekstu
Uwaga. GemBox.Pdf zawiera wbudowaną konwersję HTML do PDF opartą na Chromium. IronPDF zapewnia głęboko zintegrowany silnik renderowania Chrome z rozległymi opcjami konfiguracji dla konwersji HTML do PDF.

Zwróć uwagęGemBox.Pdf zawiera wbudowaną konwersję HTML do PDF opartą na Chromium. GemBox.Document jest oddzielnym produktem do zadań przetwarzania dokumentów.

Czym jest biblioteka IronPDF?

IronPDF wyróżnia się jako kompleksowa biblioteka .NET do obsługi plików PDF, zaprojektowana specjalnie po to, aby konwersja HTML do PDF przebiegała płynnie dla programistów. Oparty na silniku renderującym Chrome, IronPDF zmienia sposób, w jaki programiści podchodzą do generowania plików PDF w aplikacjach napisanych w językach C#, F# i VB.NET.

Filozofia biblioteki koncentruje się na wykorzystaniu istniejących umiejętności w zakresie tworzenia stron internetowych. Zamiast uczyć się skomplikowanych interfejsów API plików PDF, programiści mogą używać znanego im HTML, CSS i JavaScript do tworzenia zaawansowanych dokumentów PDF. Takie podejście znacznie skraca czas tworzenia oprogramowania, zapewniając jednocześnie idealne odwzorowanie graficzne zgodne z nowoczesnymi standardami internetowymi.

Podstawowe funkcje IronPDF

IronPDF oferuje szeroki zestaw funkcji, który obejmuje praktycznie każde zadanie związane z plikami PDF, z jakim mogą spotkać się programiści:

Doskonała konwersja HTML do PDF

  • Silnik Chrome V8: renderuje HTML przy użyciu tego samego silnika co Google Chrome, zapewniając ponad 98% zgodności z przeglądarką
  • Pełna obsługa CSS3/HTML5: Pełna obsługa nowoczesnych standardów internetowych, w tym flexbox, grid i animacji
  • Wykonanie JavaScript: Przetwarza JavaScript przed renderowaniem, doskonale przechwytując treści dynamiczne
  • Responsywny projekt: Obsługuje responsywne układy z konfigurowalnymi ustawieniami okna wyświetlania
  • Obsługa czcionek internetowych: Dokładne renderowanie czcionek Google, czcionek niestandardowych i czcionek ikonowych

Zaawansowana obróbka plików PDF

Bezpieczeństwo i zgodność z przepisami

  • Szyfrowanie: Szyfrowanie AES-256 z niestandardowymi ustawieniami uprawnień
  • Zgodność z PDF/A: Generuj pliki PDF o jakości archiwalnej do długoterminowego przechowywania
  • Redakcja: Trwałe usunięcie treści wrażliwych
  • Ochrona hasłem: Obsługa haseł użytkownika i właściciela z precyzyjnymi uprawnieniami

Przykład kodu IronPDF: HTML do PDF z zaawansowanymi funkcjami

using IronPdf;
using IronPdf.Rendering;

// Configure the Chrome renderer with advanced options
var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        // Set paper orientation and size
        PaperOrientation = PdfPaperOrientation.Portrait,
        PaperSize = PdfPaperSize.A4,

        // Configure margins (in millimeters)
        MarginTop = 25,
        MarginBottom = 25,
        MarginLeft = 20,
        MarginRight = 20,

        // Enable JavaScript execution
        EnableJavaScript = true,
        RenderDelay = 1000, // Wait 1 second for JS to complete

        // Print background colors and images
        PrintHtmlBackgrounds = true,

        // Create PDF forms from HTML form elements
        CreatePdfFormsFromHtml = true,

        // Custom header and footer
        HtmlHeader = new HtmlHeaderFooter
        {
            Height = 20,
            HtmlFragment = "<div style='text-align: center; font-size: 12px;'>Company Report - {page} of {total-pages}</div>",
            DrawDividerLine = true
        },

        HtmlFooter = new HtmlHeaderFooter
        {
            Height = 15,
            HtmlFragment = "<div style='text-align: center; font-size: 10px;'>© 2025 Company Name. Confidential.</div>"
        }
    }
};

// Convert complex HTML with CSS and JavaScript
string htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: 'Segoe UI', Arial, sans-serif; line-height: 1.6; }
        .invoice-header { 
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 30px;
            border-radius: 10px;
            margin-bottom: 30px;
        }
        .data-table { 
            width: 100%; 
            border-collapse: collapse; 
            margin-top: 20px;
        }
        .data-table th { 
            background-color: #f8f9fa; 
            padding: 12px; 
            text-align: left;
            border-bottom: 2px solid #dee2e6;
        }
        .data-table td { 
            padding: 10px; 
            border-bottom: 1px solid #dee2e6;
        }
        .total-section {
            margin-top: 30px;
            text-align: right;
            font-size: 18px;
            font-weight: bold;
        }
        @media print {
            .no-print { display: none; }
        }
    </style>
</head>
<body>
    <div class='invoice-header'>
        <h1>Invoice #INV-2025-001</h1>
        <p>Date: <span id='current-date'></span></p>
    </div>

    <table class='data-table'>
        <thead>
            <tr>
                <th>Item Description</th>
                <th>Quantity</th>
                <th>Unit Price</th>
                <th>Total</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>Professional PDF Library License</td>
                <td>1</td>
                <td>$999.00</td>
                <td>$999.00</td>
            </tr>
            <tr>
                <td>Priority Support (1 Year)</td>
                <td>1</td>
                <td>$299.00</td>
                <td>$299.00</td>
            </tr>
        </tbody>
    </table>

    <div class='total-section'>
        <p>Subtotal: $1,048.00</p>
        <p>Tax (8%): $83.84</p>
        <p style='color: #667eea; font-size: 24px;'>Total: $1,131.84</p>
    </div>

    <script>
        // Dynamic date insertion
        document.getElementById('current-date').textContent = new Date().toLocaleDateString('en-US', {
            year: 'numeric',
            month: 'long',
            day: 'numeric'
        });
    </script>
</body>
</html>";

// Render the HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Apply additional security settings
pdf.SecuritySettings.OwnerPassword = "admin123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserFormData = true;

// Add metadata
pdf.MetaData.Author = "Invoice System";
pdf.MetaData.Title = "Invoice INV-2025-001";
pdf.MetaData.Subject = "Customer Invoice";
pdf.MetaData.Keywords = "invoice, payment, 2025";
pdf.MetaData.CreationDate = DateTime.Now;

// Save the PDF
pdf.SaveAs("invoice-2025-001.pdf");

// Optional: Save as PDF/A for archival
pdf.SaveAsPdfA("invoice-2025-001-archive.pdf", PdfAVersions.PdfA3);
using IronPdf;
using IronPdf.Rendering;

// Configure the Chrome renderer with advanced options
var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        // Set paper orientation and size
        PaperOrientation = PdfPaperOrientation.Portrait,
        PaperSize = PdfPaperSize.A4,

        // Configure margins (in millimeters)
        MarginTop = 25,
        MarginBottom = 25,
        MarginLeft = 20,
        MarginRight = 20,

        // Enable JavaScript execution
        EnableJavaScript = true,
        RenderDelay = 1000, // Wait 1 second for JS to complete

        // Print background colors and images
        PrintHtmlBackgrounds = true,

        // Create PDF forms from HTML form elements
        CreatePdfFormsFromHtml = true,

        // Custom header and footer
        HtmlHeader = new HtmlHeaderFooter
        {
            Height = 20,
            HtmlFragment = "<div style='text-align: center; font-size: 12px;'>Company Report - {page} of {total-pages}</div>",
            DrawDividerLine = true
        },

        HtmlFooter = new HtmlHeaderFooter
        {
            Height = 15,
            HtmlFragment = "<div style='text-align: center; font-size: 10px;'>© 2025 Company Name. Confidential.</div>"
        }
    }
};

// Convert complex HTML with CSS and JavaScript
string htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: 'Segoe UI', Arial, sans-serif; line-height: 1.6; }
        .invoice-header { 
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 30px;
            border-radius: 10px;
            margin-bottom: 30px;
        }
        .data-table { 
            width: 100%; 
            border-collapse: collapse; 
            margin-top: 20px;
        }
        .data-table th { 
            background-color: #f8f9fa; 
            padding: 12px; 
            text-align: left;
            border-bottom: 2px solid #dee2e6;
        }
        .data-table td { 
            padding: 10px; 
            border-bottom: 1px solid #dee2e6;
        }
        .total-section {
            margin-top: 30px;
            text-align: right;
            font-size: 18px;
            font-weight: bold;
        }
        @media print {
            .no-print { display: none; }
        }
    </style>
</head>
<body>
    <div class='invoice-header'>
        <h1>Invoice #INV-2025-001</h1>
        <p>Date: <span id='current-date'></span></p>
    </div>

    <table class='data-table'>
        <thead>
            <tr>
                <th>Item Description</th>
                <th>Quantity</th>
                <th>Unit Price</th>
                <th>Total</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>Professional PDF Library License</td>
                <td>1</td>
                <td>$999.00</td>
                <td>$999.00</td>
            </tr>
            <tr>
                <td>Priority Support (1 Year)</td>
                <td>1</td>
                <td>$299.00</td>
                <td>$299.00</td>
            </tr>
        </tbody>
    </table>

    <div class='total-section'>
        <p>Subtotal: $1,048.00</p>
        <p>Tax (8%): $83.84</p>
        <p style='color: #667eea; font-size: 24px;'>Total: $1,131.84</p>
    </div>

    <script>
        // Dynamic date insertion
        document.getElementById('current-date').textContent = new Date().toLocaleDateString('en-US', {
            year: 'numeric',
            month: 'long',
            day: 'numeric'
        });
    </script>
</body>
</html>";

// Render the HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Apply additional security settings
pdf.SecuritySettings.OwnerPassword = "admin123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserFormData = true;

// Add metadata
pdf.MetaData.Author = "Invoice System";
pdf.MetaData.Title = "Invoice INV-2025-001";
pdf.MetaData.Subject = "Customer Invoice";
pdf.MetaData.Keywords = "invoice, payment, 2025";
pdf.MetaData.CreationDate = DateTime.Now;

// Save the PDF
pdf.SaveAs("invoice-2025-001.pdf");

// Optional: Save as PDF/A for archival
pdf.SaveAsPdfA("invoice-2025-001-archive.pdf", PdfAVersions.PdfA3);
Imports IronPdf
Imports IronPdf.Rendering

' Configure the Chrome renderer with advanced options
Dim renderer As New ChromePdfRenderer With {
    .RenderingOptions = New ChromePdfRenderOptions With {
        ' Set paper orientation and size
        .PaperOrientation = PdfPaperOrientation.Portrait,
        .PaperSize = PdfPaperSize.A4,

        ' Configure margins (in millimeters)
        .MarginTop = 25,
        .MarginBottom = 25,
        .MarginLeft = 20,
        .MarginRight = 20,

        ' Enable JavaScript execution
        .EnableJavaScript = True,
        .RenderDelay = 1000, ' Wait 1 second for JS to complete

        ' Print background colors and images
        .PrintHtmlBackgrounds = True,

        ' Create PDF forms from HTML form elements
        .CreatePdfFormsFromHtml = True,

        ' Custom header and footer
        .HtmlHeader = New HtmlHeaderFooter With {
            .Height = 20,
            .HtmlFragment = "<div style='text-align: center; font-size: 12px;'>Company Report - {page} of {total-pages}</div>",
            .DrawDividerLine = True
        },

        .HtmlFooter = New HtmlHeaderFooter With {
            .Height = 15,
            .HtmlFragment = "<div style='text-align: center; font-size: 10px;'>© 2025 Company Name. Confidential.</div>"
        }
    }
}

' Convert complex HTML with CSS and JavaScript
Dim htmlContent As String = "
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: 'Segoe UI', Arial, sans-serif; line-height: 1.6; }
        .invoice-header { 
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 30px;
            border-radius: 10px;
            margin-bottom: 30px;
        }
        .data-table { 
            width: 100%; 
            border-collapse: collapse; 
            margin-top: 20px;
        }
        .data-table th { 
            background-color: #f8f9fa; 
            padding: 12px; 
            text-align: left;
            border-bottom: 2px solid #dee2e6;
        }
        .data-table td { 
            padding: 10px; 
            border-bottom: 1px solid #dee2e6;
        }
        .total-section {
            margin-top: 30px;
            text-align: right;
            font-size: 18px;
            font-weight: bold;
        }
        @media print {
            .no-print { display: none; }
        }
    </style>
</head>
<body>
    <div class='invoice-header'>
        <h1>Invoice #INV-2025-001</h1>
        <p>Date: <span id='current-date'></span></p>
    </div>

    <table class='data-table'>
        <thead>
            <tr>
                <th>Item Description</th>
                <th>Quantity</th>
                <th>Unit Price</th>
                <th>Total</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>Professional PDF Library License</td>
                <td>1</td>
                <td>$999.00</td>
                <td>$999.00</td>
            </tr>
            <tr>
                <td>Priority Support (1 Year)</td>
                <td>1</td>
                <td>$299.00</td>
                <td>$299.00</td>
            </tr>
        </tbody>
    </table>

    <div class='total-section'>
        <p>Subtotal: $1,048.00</p>
        <p>Tax (8%): $83.84</p>
        <p style='color: #667eea; font-size: 24px;'>Total: $1,131.84</p>
    </div>

    <script>
        // Dynamic date insertion
        document.getElementById('current-date').textContent = new Date().toLocaleDateString('en-US', {
            year: 'numeric',
            month: 'long',
            day: 'numeric'
        });
    </script>
</body>
</html>"

' Render the HTML to PDF
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

' Apply additional security settings
pdf.SecuritySettings.OwnerPassword = "admin123"
pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserAnnotations = False
pdf.SecuritySettings.AllowUserFormData = True

' Add metadata
pdf.MetaData.Author = "Invoice System"
pdf.MetaData.Title = "Invoice INV-2025-001"
pdf.MetaData.Subject = "Customer Invoice"
pdf.MetaData.Keywords = "invoice, payment, 2025"
pdf.MetaData.CreationDate = DateTime.Now

' Save the PDF
pdf.SaveAs("invoice-2025-001.pdf")

' Optional: Save as PDF/A for archival
pdf.SaveAsPdfA("invoice-2025-001-archive.pdf", PdfAVersions.PdfA3)
$vbLabelText   $csharpLabel

Ten przykład pokazuje, jak IronPDF radzi sobie ze złożonymi układami HTML z gradientami, tabelami, dynamiczną zawartością JavaScript oraz zaawansowanymi funkcjami PDF, takimi jak ustawienia zabezpieczeń i metadane. Biblioteka przetwarza wszystko płynnie, tworząc profesjonalny plik PDF, który dokładnie odpowiada projektowi HTML.

Czym jest biblioteka GemBox.PDF?

GemBox.Pdf stanowi inne podejście do manipulacji plikami PDF w środowisku .NET. Zamiast skupiać się na konwersji HTML do PDF, GemBox.Pdf specjalizuje się w operacjach na plikach PDF na niskim poziomie oraz bezpośredniej manipulacji plikami PDF. Dzięki temu rozwiązanie to szczególnie sprawdza się w sytuacjach, w których programiści potrzebują precyzyjnej kontroli nad strukturą i treścią plików PDF.

Biblioteka doskonale radzi sobie z istniejącymi dokumentami PDF, oferując rozbudowane funkcje do odczytu, edycji i manipulacji plikami PDF na poziomie szczegółowym. GemBox.PDF działa bez zależności od programu Adobe Acrobat, co ułatwia wdrażanie w różnych środowiskach.

Podstawowe funkcje GemBox.PDF

GemBox.Pdf zapewnia kompleksowe możliwości manipulacji plikami PDF:

Operacje na dokumentach PDF

  • Odczyt i zapis plików PDF: bezpośredni dostęp do struktury i treści plików PDF
  • Łączenie i dzielenie: łączenie wielu plików PDF lub wyodrębnianie określonych stron
  • Klonowanie stron: importowanie stron między różnymi dokumentami PDF
  • Zarządzanie stronami: programowe dodawanie, usuwanie lub zmiana kolejności stron

Pobieranie i przetwarzanie treści

  • Wyodrębnianie tekstu: Wyodrębnianie tekstu Unicode wraz z informacjami o położeniu
  • Wyodrębnianie obrazów: Pobieranie obrazów osadzonych w dokumentach PDF
  • Obsługa OCR: wbudowane optyczne rozpoznawanie znaków dla zeskanowanych dokumentów
  • Redagowanie treści: Trwałe usuwanie informacji wrażliwych

Formularze i interaktywność

  • Formularze interaktywne: Twórz, wypełniaj, spłaszczaj i eksportuj formularze PDF
  • Zarządzanie polami formularzy: programowy dostęp do wszystkich typów pól formularzy
  • Adnotacje: Dodaj hiperłącza i inne adnotacje do pliku PDF

Grafika i elementy wizualne

  • Operacje rysowania: dodawanie tekstu, obrazów i grafiki wektorowej
  • Kształty i ścieżki: Twórz złożone rysunki wektorowe
  • Znaki wodne: Dodawanie tekstowych i graficznych znaków wodnych
  • Grupy treści: Organizuj treści w logiczne grupy

GemBox.Pdf Przykład kodu: Manipulacja plikami PDF i formularzami

using GemBox.Pdf;
using GemBox.Pdf.Content;
using GemBox.Pdf.Forms;
using GemBox.Pdf.Security;

// Set license (use FREE-LIMITED-KEY for evaluation)
ComponentInfo.SetLicense("FREE-LIMITED-KEY");

// Create a new PDF document from scratch
using (var document = new PdfDocument())
{
    // Add a page with custom size
    var page = document.Pages.Add();

    // Create formatted text with multiple styles
    using (var formattedText = new PdfFormattedText())
    {
        formattedText.FontSize = 24;
        formattedText.FontFamily = new PdfFontFamily("Arial");
        formattedText.Color = PdfColor.FromRgb(0.2, 0.2, 0.6);
        formattedText.AppendLine("GemBox.Pdf Document Example");

        formattedText.FontSize = 12;
        formattedText.Color = PdfColor.FromRgb(0, 0, 0);
        formattedText.AppendLine("This document demonstrates PDF creation and manipulation features.");

        // Draw text to the page
        page.Content.DrawText(formattedText, new PdfPoint(50, 700));
    }

    // Add a form to the document
    var form = document.Form;

    // Create text field
    var textField = form.Fields.AddText(page, 50, 600, 200, 30);
    textField.Name = "CustomerName";
    textField.Value = "Enter your name";
    textField.Format.Fill.Color = PdfColor.FromRgb(0.95, 0.95, 0.95);

    // Create checkbox
    var checkBox = form.Fields.AddCheck(page, 50, 550, 20, 20);
    checkBox.Name = "Agreement";
    checkBox.Checked = false;

    // Add descriptive text next to checkbox
    using (var checkboxLabel = new PdfFormattedText())
    {
        checkboxLabel.Append("I agree to the terms and conditions");
        page.Content.DrawText(checkboxLabel, new PdfPoint(80, 555));
    }

    // Create submit button
    var submitButton = form.Fields.AddButton(page, 50, 500, 100, 30);
    submitButton.Name = "Submit";
    submitButton.Actions.Activate = PdfActionType.Named;

    // Add button appearance
    using (var buttonText = new PdfFormattedText())
    {
        buttonText.Append("Submit Form");
        buttonText.FontSize = 14;
        buttonText.Color = PdfColor.FromRgb(1, 1, 1);

        // Create button appearance stream
        var appearance = submitButton.Appearance.Normal;
        appearance.Fill.Color = PdfColor.FromRgb(0.2, 0.4, 0.8);
        appearance.Stroke.Color = PdfColor.FromRgb(0.1, 0.2, 0.4);
        appearance.Stroke.Width = 1;

        // Draw button background
        appearance.DrawRectangle(new PdfPoint(0, 0), new PdfSize(100, 30), true, true);

        // Draw button text
        appearance.DrawText(buttonText, new PdfPoint(20, 10));
    }

    // Add a table using low-level graphics
    var tableTop = 400;
    var tableLeft = 50;
    var cellWidth = 150;
    var cellHeight = 30;

    // Draw table headers
    page.Content.DrawRectangle(new PdfPoint(tableLeft, tableTop), 
        new PdfSize(cellWidth * 3, cellHeight), true, true);

    using (var headerText = new PdfFormattedText())
    {
        headerText.FontSize = 12;
        headerText.Color = PdfColor.FromRgb(1, 1, 1);
        headerText.Append("Product");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + 10, tableTop + 10));

        headerText.Clear();
        headerText.Append("Quantity");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + cellWidth + 10, tableTop + 10));

        headerText.Clear();
        headerText.Append("Price");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + cellWidth * 2 + 10, tableTop + 10));
    }

    // Draw table data rows
    var rowData = new[]
    {
        new { Product = "PDF Library", Quantity = "1", Price = "$890" },
        new { Product = "Support Plan", Quantity = "1", Price = "$299" },
        new { Product = "Training", Quantity = "2", Price = "$500" }
    };

    var currentY = tableTop - cellHeight;
    foreach (var row in rowData)
    {
        // Draw cell borders
        page.Content.DrawRectangle(new PdfPoint(tableLeft, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);
        page.Content.DrawRectangle(new PdfPoint(tableLeft + cellWidth, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);
        page.Content.DrawRectangle(new PdfPoint(tableLeft + cellWidth * 2, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);

        // Draw cell content
        using (var cellText = new PdfFormattedText())
        {
            cellText.FontSize = 11;
            cellText.Append(row.Product);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + 10, currentY + 10));

            cellText.Clear();
            cellText.Append(row.Quantity);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + cellWidth + 10, currentY + 10));

            cellText.Clear();
            cellText.Append(row.Price);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + cellWidth * 2 + 10, currentY + 10));
        }

        currentY -= cellHeight;
    }

    // Apply security settings
    var securitySettings = document.SecuritySettings;
    securitySettings.DocumentOpenPassword = "user123";
    securitySettings.PermissionsPassword = "owner123";
    securitySettings.Permissions = PdfPermissions.AllowPrint | PdfPermissions.AllowFormFill;

    // Save the document
    document.Save("gembox-example.pdf");
}

// Example: Manipulating existing PDF
using (var existingDoc = PdfDocument.Load("existing-document.pdf"))
{
    // Extract text from first page
    var page = existingDoc.Pages[0];
    var text = page.Content.GetText();
    Console.WriteLine($"Extracted text: {text}");

    // Add watermark to all pages
    foreach (var p in existingDoc.Pages)
    {
        using (var watermark = new PdfFormattedText())
        {
            watermark.Append("CONFIDENTIAL");
            watermark.FontSize = 50;
            watermark.Color = PdfColor.FromRgb(0.5, 0.5, 0.5);
            watermark.Opacity = 0.3;

            // Calculate center position
            var pageWidth = p.MediaBox.Width;
            var pageHeight = p.MediaBox.Height;
            var textWidth = watermark.Width;
            var textHeight = watermark.Height;

            var x = (pageWidth - textWidth) / 2;
            var y = (pageHeight - textHeight) / 2;

            // Draw watermark diagonally
            p.Content.SaveGraphicsState();
            p.Content.SetTransform(1, 0, 0, 1, x, y);
            p.Content.SetTransform(0.7071, 0.7071, -0.7071, 0.7071, 0, 0);
            p.Content.DrawText(watermark, new PdfPoint(0, 0));
            p.Content.RestoreGraphicsState();
        }
    }

    existingDoc.Save("watermarked-document.pdf");
}
using GemBox.Pdf;
using GemBox.Pdf.Content;
using GemBox.Pdf.Forms;
using GemBox.Pdf.Security;

// Set license (use FREE-LIMITED-KEY for evaluation)
ComponentInfo.SetLicense("FREE-LIMITED-KEY");

// Create a new PDF document from scratch
using (var document = new PdfDocument())
{
    // Add a page with custom size
    var page = document.Pages.Add();

    // Create formatted text with multiple styles
    using (var formattedText = new PdfFormattedText())
    {
        formattedText.FontSize = 24;
        formattedText.FontFamily = new PdfFontFamily("Arial");
        formattedText.Color = PdfColor.FromRgb(0.2, 0.2, 0.6);
        formattedText.AppendLine("GemBox.Pdf Document Example");

        formattedText.FontSize = 12;
        formattedText.Color = PdfColor.FromRgb(0, 0, 0);
        formattedText.AppendLine("This document demonstrates PDF creation and manipulation features.");

        // Draw text to the page
        page.Content.DrawText(formattedText, new PdfPoint(50, 700));
    }

    // Add a form to the document
    var form = document.Form;

    // Create text field
    var textField = form.Fields.AddText(page, 50, 600, 200, 30);
    textField.Name = "CustomerName";
    textField.Value = "Enter your name";
    textField.Format.Fill.Color = PdfColor.FromRgb(0.95, 0.95, 0.95);

    // Create checkbox
    var checkBox = form.Fields.AddCheck(page, 50, 550, 20, 20);
    checkBox.Name = "Agreement";
    checkBox.Checked = false;

    // Add descriptive text next to checkbox
    using (var checkboxLabel = new PdfFormattedText())
    {
        checkboxLabel.Append("I agree to the terms and conditions");
        page.Content.DrawText(checkboxLabel, new PdfPoint(80, 555));
    }

    // Create submit button
    var submitButton = form.Fields.AddButton(page, 50, 500, 100, 30);
    submitButton.Name = "Submit";
    submitButton.Actions.Activate = PdfActionType.Named;

    // Add button appearance
    using (var buttonText = new PdfFormattedText())
    {
        buttonText.Append("Submit Form");
        buttonText.FontSize = 14;
        buttonText.Color = PdfColor.FromRgb(1, 1, 1);

        // Create button appearance stream
        var appearance = submitButton.Appearance.Normal;
        appearance.Fill.Color = PdfColor.FromRgb(0.2, 0.4, 0.8);
        appearance.Stroke.Color = PdfColor.FromRgb(0.1, 0.2, 0.4);
        appearance.Stroke.Width = 1;

        // Draw button background
        appearance.DrawRectangle(new PdfPoint(0, 0), new PdfSize(100, 30), true, true);

        // Draw button text
        appearance.DrawText(buttonText, new PdfPoint(20, 10));
    }

    // Add a table using low-level graphics
    var tableTop = 400;
    var tableLeft = 50;
    var cellWidth = 150;
    var cellHeight = 30;

    // Draw table headers
    page.Content.DrawRectangle(new PdfPoint(tableLeft, tableTop), 
        new PdfSize(cellWidth * 3, cellHeight), true, true);

    using (var headerText = new PdfFormattedText())
    {
        headerText.FontSize = 12;
        headerText.Color = PdfColor.FromRgb(1, 1, 1);
        headerText.Append("Product");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + 10, tableTop + 10));

        headerText.Clear();
        headerText.Append("Quantity");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + cellWidth + 10, tableTop + 10));

        headerText.Clear();
        headerText.Append("Price");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + cellWidth * 2 + 10, tableTop + 10));
    }

    // Draw table data rows
    var rowData = new[]
    {
        new { Product = "PDF Library", Quantity = "1", Price = "$890" },
        new { Product = "Support Plan", Quantity = "1", Price = "$299" },
        new { Product = "Training", Quantity = "2", Price = "$500" }
    };

    var currentY = tableTop - cellHeight;
    foreach (var row in rowData)
    {
        // Draw cell borders
        page.Content.DrawRectangle(new PdfPoint(tableLeft, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);
        page.Content.DrawRectangle(new PdfPoint(tableLeft + cellWidth, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);
        page.Content.DrawRectangle(new PdfPoint(tableLeft + cellWidth * 2, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);

        // Draw cell content
        using (var cellText = new PdfFormattedText())
        {
            cellText.FontSize = 11;
            cellText.Append(row.Product);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + 10, currentY + 10));

            cellText.Clear();
            cellText.Append(row.Quantity);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + cellWidth + 10, currentY + 10));

            cellText.Clear();
            cellText.Append(row.Price);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + cellWidth * 2 + 10, currentY + 10));
        }

        currentY -= cellHeight;
    }

    // Apply security settings
    var securitySettings = document.SecuritySettings;
    securitySettings.DocumentOpenPassword = "user123";
    securitySettings.PermissionsPassword = "owner123";
    securitySettings.Permissions = PdfPermissions.AllowPrint | PdfPermissions.AllowFormFill;

    // Save the document
    document.Save("gembox-example.pdf");
}

// Example: Manipulating existing PDF
using (var existingDoc = PdfDocument.Load("existing-document.pdf"))
{
    // Extract text from first page
    var page = existingDoc.Pages[0];
    var text = page.Content.GetText();
    Console.WriteLine($"Extracted text: {text}");

    // Add watermark to all pages
    foreach (var p in existingDoc.Pages)
    {
        using (var watermark = new PdfFormattedText())
        {
            watermark.Append("CONFIDENTIAL");
            watermark.FontSize = 50;
            watermark.Color = PdfColor.FromRgb(0.5, 0.5, 0.5);
            watermark.Opacity = 0.3;

            // Calculate center position
            var pageWidth = p.MediaBox.Width;
            var pageHeight = p.MediaBox.Height;
            var textWidth = watermark.Width;
            var textHeight = watermark.Height;

            var x = (pageWidth - textWidth) / 2;
            var y = (pageHeight - textHeight) / 2;

            // Draw watermark diagonally
            p.Content.SaveGraphicsState();
            p.Content.SetTransform(1, 0, 0, 1, x, y);
            p.Content.SetTransform(0.7071, 0.7071, -0.7071, 0.7071, 0, 0);
            p.Content.DrawText(watermark, new PdfPoint(0, 0));
            p.Content.RestoreGraphicsState();
        }
    }

    existingDoc.Save("watermarked-document.pdf");
}
Imports GemBox.Pdf
Imports GemBox.Pdf.Content
Imports GemBox.Pdf.Forms
Imports GemBox.Pdf.Security

' Set license (use FREE-LIMITED-KEY for evaluation)
ComponentInfo.SetLicense("FREE-LIMITED-KEY")

' Create a new PDF document from scratch
Using document = New PdfDocument()
	' Add a page with custom size
	Dim page = document.Pages.Add()

	' Create formatted text with multiple styles
	Using formattedText = New PdfFormattedText()
		formattedText.FontSize = 24
		formattedText.FontFamily = New PdfFontFamily("Arial")
		formattedText.Color = PdfColor.FromRgb(0.2, 0.2, 0.6)
		formattedText.AppendLine("GemBox.Pdf Document Example")

		formattedText.FontSize = 12
		formattedText.Color = PdfColor.FromRgb(0, 0, 0)
		formattedText.AppendLine("This document demonstrates PDF creation and manipulation features.")

		' Draw text to the page
		page.Content.DrawText(formattedText, New PdfPoint(50, 700))
	End Using

	' Add a form to the document
	Dim form = document.Form

	' Create text field
	Dim textField = form.Fields.AddText(page, 50, 600, 200, 30)
	textField.Name = "CustomerName"
	textField.Value = "Enter your name"
	textField.Format.Fill.Color = PdfColor.FromRgb(0.95, 0.95, 0.95)

	' Create checkbox
	Dim checkBox = form.Fields.AddCheck(page, 50, 550, 20, 20)
	checkBox.Name = "Agreement"
	checkBox.Checked = False

	' Add descriptive text next to checkbox
	Using checkboxLabel = New PdfFormattedText()
		checkboxLabel.Append("I agree to the terms and conditions")
		page.Content.DrawText(checkboxLabel, New PdfPoint(80, 555))
	End Using

	' Create submit button
	Dim submitButton = form.Fields.AddButton(page, 50, 500, 100, 30)
	submitButton.Name = "Submit"
	submitButton.Actions.Activate = PdfActionType.Named

	' Add button appearance
	Using buttonText = New PdfFormattedText()
		buttonText.Append("Submit Form")
		buttonText.FontSize = 14
		buttonText.Color = PdfColor.FromRgb(1, 1, 1)

		' Create button appearance stream
		Dim appearance = submitButton.Appearance.Normal
		appearance.Fill.Color = PdfColor.FromRgb(0.2, 0.4, 0.8)
		appearance.Stroke.Color = PdfColor.FromRgb(0.1, 0.2, 0.4)
		appearance.Stroke.Width = 1

		' Draw button background
		appearance.DrawRectangle(New PdfPoint(0, 0), New PdfSize(100, 30), True, True)

		' Draw button text
		appearance.DrawText(buttonText, New PdfPoint(20, 10))
	End Using

	' Add a table using low-level graphics
	Dim tableTop = 400
	Dim tableLeft = 50
	Dim cellWidth = 150
	Dim cellHeight = 30

	' Draw table headers
	page.Content.DrawRectangle(New PdfPoint(tableLeft, tableTop), New PdfSize(cellWidth * 3, cellHeight), True, True)

	Using headerText = New PdfFormattedText()
		headerText.FontSize = 12
		headerText.Color = PdfColor.FromRgb(1, 1, 1)
		headerText.Append("Product")
		page.Content.DrawText(headerText, New PdfPoint(tableLeft + 10, tableTop + 10))

		headerText.Clear()
		headerText.Append("Quantity")
		page.Content.DrawText(headerText, New PdfPoint(tableLeft + cellWidth + 10, tableTop + 10))

		headerText.Clear()
		headerText.Append("Price")
		page.Content.DrawText(headerText, New PdfPoint(tableLeft + cellWidth * 2 + 10, tableTop + 10))
	End Using

	' Draw table data rows
	Dim rowData = {
		New With {
			Key .Product = "PDF Library",
			Key .Quantity = "1",
			Key .Price = "$890"
		},
		New With {
			Key .Product = "Support Plan",
			Key .Quantity = "1",
			Key .Price = "$299"
		},
		New With {
			Key .Product = "Training",
			Key .Quantity = "2",
			Key .Price = "$500"
		}
	}

	Dim currentY = tableTop - cellHeight
	For Each row In rowData
		' Draw cell borders
		page.Content.DrawRectangle(New PdfPoint(tableLeft, currentY), New PdfSize(cellWidth, cellHeight), False, True)
		page.Content.DrawRectangle(New PdfPoint(tableLeft + cellWidth, currentY), New PdfSize(cellWidth, cellHeight), False, True)
		page.Content.DrawRectangle(New PdfPoint(tableLeft + cellWidth * 2, currentY), New PdfSize(cellWidth, cellHeight), False, True)

		' Draw cell content
		Using cellText = New PdfFormattedText()
			cellText.FontSize = 11
			cellText.Append(row.Product)
			page.Content.DrawText(cellText, New PdfPoint(tableLeft + 10, currentY + 10))

			cellText.Clear()
			cellText.Append(row.Quantity)
			page.Content.DrawText(cellText, New PdfPoint(tableLeft + cellWidth + 10, currentY + 10))

			cellText.Clear()
			cellText.Append(row.Price)
			page.Content.DrawText(cellText, New PdfPoint(tableLeft + cellWidth * 2 + 10, currentY + 10))
		End Using

		currentY -= cellHeight
	Next row

	' Apply security settings
	Dim securitySettings = document.SecuritySettings
	securitySettings.DocumentOpenPassword = "user123"
	securitySettings.PermissionsPassword = "owner123"
	securitySettings.Permissions = PdfPermissions.AllowPrint Or PdfPermissions.AllowFormFill

	' Save the document
	document.Save("gembox-example.pdf")
End Using

' Example: Manipulating existing PDF
Using existingDoc = PdfDocument.Load("existing-document.pdf")
	' Extract text from first page
	Dim page = existingDoc.Pages(0)
	Dim text = page.Content.GetText()
	Console.WriteLine($"Extracted text: {text}")

	' Add watermark to all pages
	For Each p In existingDoc.Pages
		Using watermark = New PdfFormattedText()
			watermark.Append("CONFIDENTIAL")
			watermark.FontSize = 50
			watermark.Color = PdfColor.FromRgb(0.5, 0.5, 0.5)
			watermark.Opacity = 0.3

			' Calculate center position
			Dim pageWidth = p.MediaBox.Width
			Dim pageHeight = p.MediaBox.Height
			Dim textWidth = watermark.Width
			Dim textHeight = watermark.Height

			Dim x = (pageWidth - textWidth) \ 2
			Dim y = (pageHeight - textHeight) \ 2

			' Draw watermark diagonally
			p.Content.SaveGraphicsState()
			p.Content.SetTransform(1, 0, 0, 1, x, y)
			p.Content.SetTransform(0.7071, 0.7071, -0.7071, 0.7071, 0, 0)
			p.Content.DrawText(watermark, New PdfPoint(0, 0))
			p.Content.RestoreGraphicsState()
		End Using
	Next p

	existingDoc.Save("watermarked-document.pdf")
End Using
$vbLabelText   $csharpLabel

Ten przykład pokazuje mocne strony GemBox.Pdf w zakresie niskopoziomowej manipulacji plikami PDF, demonstrując tworzenie formularzy, rysowanie grafiki oraz funkcje zabezpieczeń dokumentów. Chociaż kod jest bardziej rozbudowany niż podejście HTML stosowane w IronPDF, zapewnia precyzyjną kontrolę nad każdym aspektem pliku PDF.

Jak te biblioteki radzą sobie z konwersją HTML do PDF?

Podejście do konwersji HTML na PDF stanowi jedną z najważniejszych różnic między IronPDF a GemBox.Pdf.

Podejście IronPDF do konwersji HTML na PDF

IronPDF został stworzony od podstaw z myślą przede wszystkim o konwersji HTML do PDF. Biblioteka zawiera pełny silnik renderujący Chrome, który przetwarza HTML, CSS i JavaScript dokładnie tak, jak robiłaby to przeglądarka internetowa. Oznacza to, że:

  • Prawdziwe renderowanie przeglądarki: Wykorzystuje ten sam silnik Blink, co przeglądarka Google Chrome
  • Pełna zgodność ze standardami internetowymi: pełna obsługa CSS3, HTML5, flexbox, grid oraz nowoczesnego JavaScript
  • Dynamiczna zawartość: Wykonuje kod JavaScript przed renderowaniem, przechwytując zawartość AJAX i elementy dynamiczne
  • Responsywny projekt: Obsługuje zapytania o media i responsywne układy
  • Zasoby zewnętrzne: automatycznie pobiera obrazy, arkusze stylów i czcionki z adresów URL

Podejście HTML do PDF przez GemBox.Pdf

GemBox.Pdf zawiera wbudowaną konwersję HTML do PDF, używającą silnika renderującego Chromium, wspierającą HTML5, CSS3 i egzekucję JavaScript. Konwersja może być przeprowadzana z plików lokalnych, aktywnych URL, ciągów HTML lub strumieni za pomocą API ConversionOptions.

IronPDF wyróżnia się w tej dziedzinie dzięki głębokiej integracji Chrome V8 i bogatszej powierzchni konfiguracyjnej — w tym niestandardowe nagłówki/stopki, tokeny numerowania stron, kontrolki tła druku, opóźnienia renderowania dla stron obciążonych JavaScript i rozległe opcje zabezpieczeń/metadata, wszystkie dostępne z jednego, zintegrowanego API.

Obsługa nowoczesnych frameworków CSS: kluczowa różnica

Jedna z najważniejszych zalet renderowania opartego na przeglądarce Chrome w IronPDF staje się widoczna podczas pracy z nowoczesnymi frameworkami CSS, takimi jak Bootstrap, Tailwind CSS i Foundation. Frameworki te stały się podstawą nowoczesnych aplikacji internetowych, a ich zdolność do prawidłowego renderowania w plikach PDF jest niezbędna w wielu przypadkach użycia.

IronPDF: Pełna obsługa nowoczesnych frameworków

Silnik renderujący IronPDF dla przeglądarki Chrome zapewnia pełną, natywną obsługę wszystkich nowoczesnych frameworków CSS:

  • Bootstrap 5: Pełne wsparcie dla flexbox i CSS Grid dla układów responsywnych
  • Tailwind CSS: Pełna obsługa frameworka CSS opartego na podejściu "utility-first"
  • Przykłady z życia wzięte: renderuje stronę główną Bootstrap oraz szablony Bootstrap z idealną dokładnością pikselową
  • Nowoczesne funkcje CSS3: animacje, transformacje, przejścia, właściwości niestandardowe
  • Responsywne projekty: zapytania o media i układy oparte na oknie wyświetlania działają płynnie

Przykład kodu: Formularz Bootstrap do pliku PDF

using IronPdf;

var renderer = new ChromePdfRenderer();

string bootstrapForm = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
    <div class='container mt-5'>
        <h1 class='mb-4'>Customer Registration</h1>
        <form class='needs-validation'>
            <div class='row g-3'>
                <div class='col-md-6'>
                    <label class='form-label'>First Name</label>
                    <input type='text' class='form-control' value='John'>
                </div>
                <div class='col-md-6'>
                    <label class='form-label'>Last Name</label>
                    <input type='text' class='form-control' value='Smith'>
                </div>
            </div>
            <div class='mt-4'>
                <button class='btn btn-primary' type='submit'>Submit</button>
            </div>
        </form>
    </div>
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(bootstrapForm);
pdf.SaveAs("bootstrap-form.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

string bootstrapForm = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
    <div class='container mt-5'>
        <h1 class='mb-4'>Customer Registration</h1>
        <form class='needs-validation'>
            <div class='row g-3'>
                <div class='col-md-6'>
                    <label class='form-label'>First Name</label>
                    <input type='text' class='form-control' value='John'>
                </div>
                <div class='col-md-6'>
                    <label class='form-label'>Last Name</label>
                    <input type='text' class='form-control' value='Smith'>
                </div>
            </div>
            <div class='mt-4'>
                <button class='btn btn-primary' type='submit'>Submit</button>
            </div>
        </form>
    </div>
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(bootstrapForm);
pdf.SaveAs("bootstrap-form.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

Dim bootstrapForm As String = "
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
    <div class='container mt-5'>
        <h1 class='mb-4'>Customer Registration</h1>
        <form class='needs-validation'>
            <div class='row g-3'>
                <div class='col-md-6'>
                    <label class='form-label'>First Name</label>
                    <input type='text' class='form-control' value='John'>
                </div>
                <div class='col-md-6'>
                    <label class='form-label'>Last Name</label>
                    <input type='text' class='form-control' value='Smith'>
                </div>
            </div>
            <div class='mt-4'>
                <button class='btn btn-primary' type='submit'>Submit</button>
            </div>
        </form>
    </div>
</body>
</html>"

Dim pdf = renderer.RenderHtmlAsPdf(bootstrapForm)
pdf.SaveAs("bootstrap-form.pdf")
$vbLabelText   $csharpLabel

GemBox.Pdf: Wsparte Frameworki oparte na Chromium

GemBox.Pdf wykorzystuje silnik Chromium do konwersji HTML do PDF, który zapewnia podstawowe wsparcie dla HTML5 i CSS3. Nowoczesne frameworki CSS, które polegają na standardowym renderowaniu przeglądarkowym, powinny być kompatybilne na poziomie silnika.

Zaletą IronPDF w tej kwestii jest jego dokładnie udokumentowane i przetestowane wsparcie dla Bootstrap, Tailwind CSS i innych frameworków, z wyraźnymi przykładami, przewodnikami rozwiązywania problemów i opcjami konfiguracji (takimi jak ustawienia viewport i opóźnienia renderowania), które są częścią jego głównej powierzchni API. Użytkownicy IronPDF korzystają z rozległych zasobów społecznościowych i oficjalnych wskazówek dla wspólnych scenariuszy renderowania specyficznych dla frameworków.

Rozważanie w prawdziwym świecie: Jeśli twój projekt wymaga precyzyjnej kontroli nad tym, jak układy Bootstrap lub Tailwind renderują się w PDF — w tym niestandardowe rozmiary viewport, treści napędzane JavaScript czy renderowanie dynamiczne wykresów — bogatsze API konfiguracyjne IronPDF i oficjalne przewodniki frameworków dostarczają bardziej bezpośrednią ścieżkę do rezultatów jakości produkcyjnej.

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

Która biblioteka najlepiej sprawdza się w różnych zadaniach związanych z plikami PDF?

Zrozumienie, w czym każda biblioteka się wyróżnia, pomaga programistom wybrać odpowiednie narzędzie do ich konkretnych potrzeb.

W czym IronPDF się wyróżnia

IronPDF jest dobrze dopasowanym do takich scenariuszy:

1. Generowanie plików PDF w aplikacjach internetowych

Idealny do aplikacji SaaS, portali internetowych i wszelkich systemów, które wymagają konwersji treści internetowych do formatu PDF. Silnik renderujący Chrome zapewnia idealne wyświetlanie złożonych układów stron internetowych, w tym tych wykorzystujących Bootstrap, Tailwind CSS lub niestandardowe frameworki.

2. Dynamiczne generowanie raportów

Gdy raporty zawierają wykresy (Chart.js, D3.js), dynamiczną wizualizację danych lub treści renderowane w JavaScript, IronPDF dokładnie je przechwytuje. Dzięki temu idealnie nadaje się do pulpitów analitycznych i aplikacji opartych na danych.

3. Szablony faktur i dokumentów

Korzystanie z szablonów HTML/CSS do tworzenia faktur, paragonów i dokumentów biznesowych pozwala projektantom tworzyć szablony bez konieczności nauki API specyficznych dla formatu PDF. Zmiany można wprowadzać szybko, korzystając ze znanych technologii internetowych.

4. Projekty szybkiego rozwoju

Proste API i podejście oparte na HTML znacznie skracają czas programowania. Programista może stworzyć złożony plik PDF w ciągu kilku minut, a nie godzin.

5. Wdrażanie wielopłatformowe

Dzięki natywnej obsłudze systemów Windows, Linux, macOS, Docker oraz platform chmurowych, IronPDF ułatwia wdrażanie w różnych środowiskach.

W czym GemBox.PDF się wyróżnia

GemBox.PDF wykazuje swoje mocne strony w następujących obszarach:

1. Manipulacja plikami PDF na niskim poziomie

Gdy wymagana jest precyzyjna kontrola nad strukturą pliku PDF, obiektowe podejście GemBox.Pdf zapewnia bezpośredni dostęp do elementów, strumieni i słowników PDF.

2. Aplikacje z dużą ilością formularzy

W przypadku aplikacji, które intensywnie wykorzystują formularze PDF, GemBox.Pdf oferuje kompleksową obsługę pól formularzy, w tym programowe tworzenie złożonych formularzy interaktywnych.

3. Wymagania dotyczące OCR

Dzięki wbudowanym funkcjom OCR GemBox.PDF może wyodrębniać tekst ze skanowanych dokumentów bez konieczności korzystania z dodatkowych bibliotek, co sprawia, że nadaje się do projektów digitalizacji dokumentów.

4. Tworzenie aplikacji mobilnych

Natywna obsługa platform Android i iOS sprawia, że GemBox.Pdf jest dobrym wyborem dla aplikacji mobilnych, które wymagają funkcjonalności PDF.

5. Modyfikacja istniejącego pliku PDF

W przypadku pracy głównie z istniejącymi plikami PDF, a nie tworzenia nowych, narzędzia GemBox.Pdf do wyodrębniania, manipulowania i modyfikowania doskonale nadają się do tego zadania.

Jak wygląda porównanie instalacji i konfiguracji?

Obie biblioteki oferują prostą instalację za pośrednictwem NuGet, ale o różnym stopniu złożoności.

Instalacja IronPDF

Instalacja IronPDF jest niezwykle prosta:

Install-Package IronPdf

Lub za pomocą interfejsu CLI platformy .NET:

dotnet add package IronPdf

Pakiet zawiera wszystko, co jest potrzebne, w tym silnik renderujący Chrome. W większości przypadków nie są wymagane żadne dodatkowe konfiguracje ani zależności.

W konkretnych scenariuszach wdrożeniowych IronPDF oferuje:

  • IronPdf.Slim: Lekki pakiet pobierający komponenty specyficzne dla platformy w czasie wykonywania
  • IronPdf.Linux: Wstępnie skonfigurowany do wdrożeń Linux
  • IronPdf.MacOs: Optymalizowany dla środowisk macOS

Instalacja GemBox.PDF

Instalacja GemBox.Pdf jest równie prosta, jeśli chodzi o podstawową obsługę plików PDF:

Install-Package GemBox.Pdf

Jednak w przypadku konwersji HTML do PDF potrzebne będą:

Install-Package GemBox.Document

Obie biblioteki wymagają konfiguracji klucza licencyjnego:

// IronPDF
License.LicenseKey = "YOUR-LICENSE-KEY";

// GemBox.Pdf
ComponentInfo.SetLicense("YOUR-LICENSE-KEY");
// IronPDF
License.LicenseKey = "YOUR-LICENSE-KEY";

// GemBox.Pdf
ComponentInfo.SetLicense("YOUR-LICENSE-KEY");
' IronPDF
License.LicenseKey = "YOUR-LICENSE-KEY"

' GemBox.Pdf
ComponentInfo.SetLicense("YOUR-LICENSE-KEY")
$vbLabelText   $csharpLabel

Jakie są różnice w licencjonowaniu i cenach?

Zrozumienie modeli licencyjnych pomaga określić całkowity koszt posiadania każdego rozwiązania.

Licencjonowanie IronPDF

IronPDF oferuje przejrzyste, stopniowane licencjonowanie (ceny na kwiecień 2026):

  • Licencja Lite: $999

    • 1 programista
    • 1 projekt
    • 1 rok wsparcia i aktualizacji

  • Licencja Plus: $1,499

    • 3 programistów
    • 3 projekty
    • 1 rok wsparcia i aktualizacji
  • Licencja Professional: $2,999
    • 10 programistów
    • 10 projektów
    • 1 rok wsparcia i aktualizacji

Dodatkowe opcje:

  • Redystrybucja bez opłat licencyjnych: +$1,999
  • Dostępne licencje SaaS/Licencjonowanie OEM
  • Pakiet Iron Suite: $2,998 dla 10 produktów

Kluczowe zalety:

  • 30-dniowa gwarancja zwrotu
  • Licencje wieczyste (jednorazowy zakup)
  • Bezpłatne tworzenie i testowanie
  • Wdrożenie w środowisku dev/staging/produkcyjnym w cenie

Licencjonowanie GemBox.PDF

GemBox oferuje licencjonowanie per-deweloper (ceny na kwiecień 2026):

  • Pojedynczy Deweloper: $890
    • 1 programista
    • Nieograniczona liczba projektów
    • 1 rok wsparcia i aktualizacji
    • Wliczone w cenę wdrożenie bez opłat licencyjnych

Ważne uwagi:

  • 40% zniżki na przedłużenie (60%, jeśli przedłużysz przed upływem terminu)
  • GemBox Bundle: $2,200 dla 1 dewelopera (6 produktów)

Kluczowe zalety:

  • 30-dniowa gwarancja zwrotu
  • Licencje wieczyste
  • W cenie nieograniczona liczba wdrożeń
  • Nie są wymagane żadne licencje serwerowe ani OEM

Porównanie kosztów dla typowych scenariuszy

Scenariusz Koszt IronPDF Koszt GemBox.Pdf
Pojedynczy programista, HTML do PDF $999 $890
3 programistów, wyłącznie obróbka plików PDF $1,499 $4,450 (do 10 deweloperów)
3 programistów, HTML do PDF $1,499 $4,450 (do 10 deweloperów)
Enterprise (10 programistów), pełen zestaw funkcji $2,999 $4,450

Którą bibliotekę wybrać?

Wybór między IronPDF a GemBox.Pdf zależy od konkretnych wymagań:

Kiedy wybrać IronPDF:

  • Bogata konfiguracja HTML do PDF jest priorytetem: IronPDF oferuje rozległe API dla nagłówków/stopków, opóźnień renderowania JavaScript, ustawień viewport, zabezpieczeń PDF i metadata — wszystko w jednej zintegrowanej bibliotece
  • Potrzebujesz głęboko udokumentowanej integracji z frameworkami: Oficjalne przewodniki i przetestowane przykłady dla Bootstrap, Tailwind CSS, Chart.js i innych frameworków webowych
  • Ważny jest szybki rozwój: Proste, wysokopoziomowe metody API, takie jak RenderHtmlAsPdf(), skracają czas wprowadzenia na rynek
  • Potrzebne jest wdrożenie międzyplatformowe: Doskonałe wsparcie dla chmury i środowisk kontenerowych, z dedykowanymi pakietami Linux i macOS
  • Budżet jest istotny: Niższy koszt wejścia i szeroki zestaw funkcji z jednej biblioteki

Kiedy wybrać GemBox.PDF:

  • Niezbędna jest kontrola nad plikami PDF na niskim poziomie: bezpośredni dostęp do obiektów i struktury plików PDF
  • Wymagana jest obsługa platform mobilnych: natywna kompatybilność z systemami Android i iOS
  • OCR jest podstawowym wymogiem: wbudowany OCR bez dodatkowych zależności
  • Pracujesz głównie z istniejącymi plikami PDF: zaawansowane funkcje manipulacji i ekstrakcji
  • Nielimitowane wdrożenie jest ważne: Redystrybucja bez opłat licencyjnych w zestawie bez dodatkowych kosztów

Rozważ użycie obu bibliotek, gdy:

Niektóre organizacje dostrzegają wartość w wykorzystaniu obu bibliotek w różnych częściach swojej aplikacji:

  • IronPDF do generowania raportów i konwersji HTML do PDF
  • GemBox.Pdf do przetwarzania formularzy i manipulacji plikami PDF

Pierwsze kroki z wybraną biblioteką

Obie biblioteki oferują bezpłatne wersje próbne, które pozwalają ocenić ich możliwości:

Wypróbuj IronPDF

  1. Zainstaluj pakiet NuGet
  2. Do programowania nie jest wymagany klucz licencyjny
  3. W trybie próbnym na plikach PDF pojawiają się znaki wodne
  4. Pełny dostęp do funkcji podczas okresu próbnego

Pobierz bezpłatną wersję próbną IronPDF

Wypróbuj GemBox.PDF

  1. Zainstaluj pakiet NuGet
  2. Użyj ComponentInfo.SetLicense("FREE-LIMITED-KEY")
  3. Ograniczone do 2 stron w trybie darmowym
  4. Aktualizacja w celu usunięcia ograniczeń

Wizualny przewodnik instalacji

Dla programistów preferujących interfejs graficzny Visual Studio przygotowaliśmy przewodnik krok po kroku dotyczący instalacji obu bibliotek:

Tworzenie nowego projektu ASP.NET

Okno dialogowe Okno dialogowe "Nowy projekt" programu Visual Studio służące do tworzenia aplikacji internetowych ASP.NET — podstawa projektów związanych z generowaniem plików PDF

Ekran wyboru szablonu projektu ASP.NET z zaznaczoną opcją Web Forms do integracji biblioteki PDF Wybór Web Forms jako szablonu projektu — odpowiedniego zarówno dla implementacji IronPDF, jak i GemBox.Pdf

Instalowanie bibliotek PDF za pośrednictwem NuGet

Menu kontekstowe Solution Explorer z opcją Zarządzaj pakietami NuGet służącą do dodawania bibliotek PDF Kliknij prawym przyciskiem myszy swój projekt w Eksploratorze rozwiązań, aby uzyskać dostęp do Menedżera pakietów NuGet w celu zainstalowania biblioteki

Menu projektu Visual Studio wyświetlające opcję Zarządzaj pakietami NuGet do instalacji biblioteki PDF Alternatywny dostęp do menedżera pakietów NuGet poprzez menu Projekt w Visual Studio

Interfejs menedżera pakietów NuGet pokazujący instalację IronPDF wraz ze szczegółami wersji i opisem Instalacja IronPDF za pomocą menedżera pakietów NuGet — zwróć uwagę na obszerny opis funkcji i liczbę pobrań

Alternatywne metody instalacji

Strona pobierania na oficjalnej witrynie IronPDF z opcją bezpośredniego pobrania pliku DLL do ręcznej instalacji Witryna internetowa IronPDF oferuje bezpośrednie pobieranie bibliotek DLL w sytuacjach, w których instalacja za pomocą NuGet nie jest odpowiednia.

Wnioski

Zarówno IronPDF, jak i GemBox.Pdf to wysokiej jakości biblioteki PDF dla programistów .NET, z których każda ma swoje mocne strony. Obie biblioteki zawierają konwersję HTML do PDF opartą na Chromium; IronPDF wyróżnia się poprzez bogatsze API konfiguracyjne, głębszą dokumentację dla frameworków webowych i szerszy zestaw funkcji w jednym pakiecie. GemBox.Pdf sprawdza się w niskopoziomowej manipulacji PDF, wsparciu dla platform mobilnych i wbudowanym OCR, co czyni go dobrze dopasowanym do aplikacji wymagających precyzyjnej kontroli struktury PDF.

Dla programistów webowych i zespołów budujących nowoczesne aplikacje, które chcą dokładnie udokumentowanego, wysoce konfigurowalnego przepływu pracy HTML do PDF, zintegrowane API IronPDF i szerokie wsparcie ekosystemu zmniejsza czas rozwoju i złożoność.

Jednak GemBox.Pdf pozostaje solidnym wyborem w specjalistycznych scenariuszach, zwłaszcza w tworzeniu aplikacji mobilnych i aplikacji skupionych na przetwarzaniu formularzy PDF lub wymaganiach OCR.

Chcesz przekształcić swoje treści HTML w profesjonalne pliki PDF? Zacznij korzystać z bezpłatnej wersji próbnej IronPDF i przekonaj się o mocy renderowania na poziomie przeglądarki Chrome w swoich aplikacjach .NET. Dzięki obszernej dokumentacji, licznym przykładom kodu i responsywnemu wsparciu technicznemu będziesz generować pliki PDF w ciągu kilku minut, a nie godzin.

Zwróć uwagęGemBox.PDF i GemBox.Document są zastrzeżonymi znakami towarowymi ich właścicieli. Ta strona nie jest powiązana z GemBox.PDF ani GemBox.Document, nie jest przez nie 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#?

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.

Czy mogę manipulować istniejącymi plikami PDF za pomocą tych bibliotek?

Tak, zarówno IronPDF, jak i GemBox.Pdf mogą służyć do manipulacji istniejącymi plikami PDF. IronPDF upraszcza typowe zadania, takie jak scałanie, dzielenie i dodawanie znaków wodnych. GemBox.Pdf oferuje bardziej szczegółową kontrolę nad obiektami PDF, co jest przydatne przy skomplikowanych zadaniach manipulacji.

Jakie są zalety używania IronPDF do konwersji HTML do PDF?

IronPDF oferuje doskonałą jakość konwersji HTML do PDF dzięki silnikowi renderującemu Chrome V8, osiągając ponad 98% zgodności z przeglądarką. Obsługuje nowoczesny CSS3, HTML5, wykonywanie JavaScript, czcionki internetowe i responsywne projekty.

Która biblioteka jest bardziej opłacalna dla małego zespołu deweloperskiego?

Dla zespołu 3 deweloperów potrzebującego konwersji HTML do PDF, IronPDF kosztuje 1 499 USD za licencję Plus, podczas gdy GemBox kosztowałby 5 340 USD za 3 licencje GemBox.Pdf i 3 licencje GemBox.Document. IronPDF oferuje znacznie lepszą wartość dla zespołów.

Czy IronPDF nadaje się do generowania dużej ilości plików PDF?

Tak, IronPDF zapewnia doskonałą wydajność, z czasem renderowania HTML do PDF około 125 ms, zoptymalizowanym wsparciem async/await i efektywnym zużyciem pamięci poniżej 10 MB. Jest doskonale dostosowany do webowego generowania PDF w dużej skali.

Jakie wsparcie jest wliczone w IronPDF?

IronPDF obejmuje wsparcie inżynieryjne 24/5 z bezpośrednim dostępem do zespołu deweloperskiego i typowym czasem odpowiedzi 24-48 godzin, wraz z kompleksową dokumentacją i przykładami kodu.

Czy mogę tworzyć dokumenty zgodne z PDF/A za pośrednictwem tych bibliotek?

Tak, IronPDF może generować dokumenty zgodne z PDF/A za pomocą prostego wywołania metody, takiej jak SaveAsPdfA(), obsługując wiele wersji PDF/A. GemBox.Pdf może odczytywać dokumenty PDF/A i utrzymywać zgodność podczas ich modyfikacji.

Czy te biblioteki są kompatybilne z nowoczesnymi frameworkami .NET?

Tak, obie biblioteki wspierają nowoczesne wersje .NET. IronPDF wspiera .NET Framework 4.6.2+, .NET Core 3.1+ i .NET 5 do 10. GemBox.Pdf wspiera .NET Framework 3.5+, .NET Standard 2.0 i .NET 6+.

Która biblioteka jest zoptymalizowana do wdrażania w chmurze?

IronPDF jest zoptymalizowany do wdrażania w chmurze z wsparciem dla Azure, AWS, kontenerów Docker i środowisk bezserwerowych. Jego podejście oparte na HTML doskonale współgra z aplikacjami internetowymi, czyniąc go lepszym wyborem dla aplikacji SaaS.

Czy jest dostępna darmowa wersja do testowania IronPDF?

IronPDF oferuje darmową opcję testową umożliwiającą nieograniczone rozwijanie i testowanie bez klucza licencyjnego, chociaż na wyjściu pojawią się znaki wodne. Zapewnia to wystarczającą funkcjonalność do oceny produktu przed zakupem.

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