Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Produktvergleiche
  4. Gembox.Pdf
PRODUKTVERGLEICHE

IronPDF vs GemBox.Pdf: Vollständiger .NET PDF-Bibliotheksvergleich für HTML zu PDF Konvertierung

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Bei der Entwicklung von .NET-Anwendungen, die die Erzeugung und Bearbeitung von PDF-Dateien erfordern, kann die Wahl der richtigen C# PDF-Bibliothek den Erfolg Ihres Projekts erheblich beeinflussen. Dieser umfassende Vergleich untersucht IronPDF und GemBox.Pdf, zwei prominente .NET-PDF-Bibliotheken, um Entwicklern eine fundierte Entscheidung basierend auf Funktionen, Leistung, Preisgestaltung und praxisnahen Anwendungsfällen zu ermöglichen.

Kurzer Überblick über den Vergleich

Überblick über den Produktvergleich
Funktionsvergleich von IronPDF und GemBox.Pdf für die .NET-Entwicklung
Kategorie Merkmal/Aspekt IronPDF GemBox.Pdf Hauptvorteil
**Kernarchitektur** Design-Philosophie HTML-first, Chrome-Rendering PDF-native Manipulation Kontextabhängig
API-Komplexität Einfache Methoden wie `RenderHtmlAsPdf()` PDF-Objekte auf niedriger Ebene IronPDF: Schnellere Entwicklung
Lernkurve typisch 1-2 Tage 3-5 Tage typisch IronPDF: Schnellere Akzeptanz
**Plattform-Unterstützung** Plattformübergreifend Windows, Linux, macOS, Docker Windows, Linux, macOS, Android, iOS GemBox: Mobile Unterstützung
.NET-Versionen .NET 10, 9, 8, 7, 6, 5, Core 3.1+, Framework 4.6.2+ .NET 6, Standard 2.0, Framework 3.5+ IronPDF: Neueste .NET-Unterstützung
Cloud-Plattformen Azure/AWS optimiert Standard-Cloud-Unterstützung IronPDF: Cloud-fähig
**HTML zu PDF** Rendering-Engine Vollständige Chrome V8-Engine Keine integrierte HTML-Unterstützung* IronPDF: Natives HTML zu PDF
CSS3/HTML5-Unterstützung Vollständige Unterstützung Erfordert GemBox.Document IronPDF: Moderne Webstandards
JavaScript-Ausführung Volle JavaScript-Unterstützung Keine JavaScript-Unterstützung IronPDF: Dynamischer Inhalt
Rendering-Geschwindigkeit ~125ms typisch N/A (keine HTML-Unterstützung) IronPDF: Schnelles Rendering
**Erfahrung des Entwicklers** Codebeispiele 100+ fertige Beispiele mehr als 100 Beispiele verfügbar Beides: Umfangreiche Ressourcen
Dokumentation Tutorials, Anleitungen, Videos Schwerpunkt API-Dokumentation IronPDF: Mehrere Lernpfade
**Inhaltsmanipulation** PDFs zusammenführen/teilen Eingebaute Methoden Eingebaute Methoden Beide: Standardfunktionen
Textextraktion Unicode-Unterstützung, OCR-Integration Unicode-Unterstützung, integrierte OCR GemBox: Eingebaute OCR
Formulare unterstützen HTML-Formulare in PDF-Formulare Formulare erstellen, ausfüllen, glätten Kontextabhängig
**Leistungskennzahlen** Speicherverwendung Typischerweise unter 10 MB Geringer Speicherbedarf Beide: Effizient
Threading-Unterstützung Natives async/await optimiert Thread-sichere Operationen IronPDF: Bessere async-Unterstützung
**Security & Encryption** Verschlüsselungsstufen AES-256, benutzerdefinierte Handler AES-256-Standard Beides: Industriestandard
Digitale Signaturen Integrierte, visuelle Signaturen Unterstützung für digitale Signaturen Beides: Unterstützung von Signaturen
**Licensing & Pricing** Einstiegsstufe Lite: $999 (1 dev, 1 project) Einzelner Entwickler: $890 (1 Entwickler, unbegrenzte Projekte) IronPDF: Niedrigere Einstiegskosten
Weitervertrieb +$1.999 lizenzgebührenfrei Inklusive, unbegrenzte Einsätze GemBox: Bessere Begriffe für die Bereitstellung
Suite-Option Iron Suite: $1,498 (9 products) GemBox-Paket: $2.200 (7 Produkte) IronPDF: Besserer Wert der Suite
**Unterstützung** Inklusive Unterstützung Ja, 24/5 technische Unterstützung Ja, 1 Jahr professioneller Support Beides: Gute Unterstützung
Reaktionszeit typischerweise 24-48 Stunden Innerhalb von 1 Arbeitstag Beides: Schnelle Reaktion
**Best für** Anwendungsfälle HTML zu PDF, Webanwendungen, Berichte PDF-Bearbeitung, Formulare, OCR Kontextabhängig
*Hinweis.* GemBox.Pdf konzentriert sich auf die PDF-Bearbeitung und erfordert GemBox.Document für die HTML-Konvertierung. IronPDF bietet eine native HTML-zu-PDF-Konvertierung mit vollständigem Browser-Rendering. *Die HTML-Unterstützung in GemBox erfordert den Erwerb eines zusätzlichen Produkts.

Hinweis:GemBox.Pdf benötigt die separate GemBox.Document-Bibliothek (zusätzliche 890 $) für die HTML-zu-PDF-Konvertierung.

Was ist die IronPDF-Bibliothek?

IronPDF hebt sich als umfassende .NET PDF-Bibliothek hervor, die speziell entwickelt wurde, um HTML zu PDF-Konvertierung für Entwickler nahtlos zu gestalten. Mit einer Chrome-Rendering-Engine im Kern verändert IronPDF die Art und Weise, wie Entwickler die PDF-Erzeugung in C#, F# und VB.NET-Anwendungen angehen.

Die Philosophie der Bibliothek konzentriert sich darauf, vorhandene Webentwicklungskompetenzen zu nutzen. Anstatt komplexe PDF-APIs zu erlernen, können Entwickler vertraute HTML-, CSS- und JavaScript-Technologien verwenden, um anspruchsvolle PDF-Dokumente zu erstellen. Dieser Ansatz verkürzt die Entwicklungszeit erheblich und gewährleistet eine pixelgenaue Wiedergabe, die den modernen Webstandards entspricht.

Kernfunktionen von IronPDF

IronPDF bietet ein umfangreiches Funktionsset, das nahezu alle PDF-bezogenen Aufgaben abdeckt, auf die Entwickler stoßen könnten:

Exzellenz bei der HTML-zu-PDF-Konvertierung

  • Chrome V8 Engine: Rendert HTML mit derselben Engine wie Google Chrome und gewährleistet so eine Browsertreue von über 98 %.
  • Volle CSS3/HTML5-Unterstützung: Umfassende Unterstützung für moderne Webstandards einschließlich Flexbox, Grid und Animationen
  • JavaScript -Ausführung: Verarbeitet JavaScript vor dem Rendern und erfasst dynamische Inhalte perfekt.
  • Responsives Design: Unterstützt responsive Layouts mit anpassbaren Viewport-Einstellungen
  • Unterstützung für Webfonts: Stellt Google Fonts, benutzerdefinierte Schriftarten und Symbolfonts korrekt dar.

Erweiterte PDF-Manipulation

Sicherheit und Konformität

  • Verschlüsselung : AES-256-Verschlüsselung mit benutzerdefinierten Berechtigungseinstellungen
  • PDF/A-Konformität : Erstellung von PDFs in Archivqualität für die Langzeitarchivierung
  • Schwärzung : Sensible Inhalte dauerhaft entfernen
  • Passwortschutz: Unterstützung von Benutzer- und Besitzerpasswörtern mit differenzierten Berechtigungen

IronPDF Code Beispiel: HTML zu PDF mit erweiterten Funktionen

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

Dieses Beispiel zeigt die Fähigkeit von IronPDF, komplexe HTML-Layouts mit Verläufen, Tabellen, dynamischen JavaScript-Inhalten und erweiterten PDF-Funktionen wie Sicherheitseinstellungen und Metadaten zu behandeln. Die Bibliothek verarbeitet alles nahtlos und erzeugt ein professionelles PDF, das dem HTML-Design exakt entspricht.

Was ist die GemBox.Pdf-Bibliothek?

GemBox.Pdf repräsentiert einen anderen Ansatz zur PDF-Bearbeitung in .NET. Anstatt sich auf die Konvertierung von HTML in PDF zu konzentrieren, spezialisiert sich GemBox.Pdf auf niedrigstufige PDF-Operationen und die direkte PDF-Manipulation. Dies macht es besonders geeignet für Szenarien, in denen Entwickler eine präzise Kontrolle über die PDF-Struktur und den Inhalt benötigen.

Die Bibliothek ist hervorragend im Umgang mit bestehenden PDF-Dokumenten und bietet robuste Funktionen zum Lesen, Bearbeiten und Bearbeiten von PDF-Dateien auf granularer Ebene. GemBox.Pdf arbeitet ohne Abhängigkeiten von Adobe Acrobat, was die Bereitstellung in verschiedenen Umgebungen unkompliziert macht.

Kernfunktionen von GemBox.Pdf

GemBox.Pdf bietet umfangreiche PDF-Bearbeitungsfähigkeiten:

PDF-Dokumente bearbeiten

  • PDFs lesen und schreiben: Direkter Zugriff auf PDF-Struktur und -Inhalt
  • Zusammenführen und Aufteilen: Mehrere PDFs kombinieren oder bestimmte Seiten extrahieren
  • Seiten klonen: Seiten zwischen verschiedenen PDF-Dokumenten importieren
  • Seitenverwaltung: Seiten programmatisch hinzufügen, entfernen oder neu anordnen

Inhaltsextraktion und -manipulation

  • Textextraktion: Unicode-Text mit Positionsinformationen extrahieren
  • Bildextraktion: Eingebettete Bilder aus PDF-Dokumenten abrufen
  • OCR-Unterstützung: Integrierte optische Zeichenerkennung für gescannte Dokumente
  • Inhaltsschwärzung: Sensible Informationen dauerhaft entfernen

Formulare und Interaktivität

  • Interaktive Formulare: PDF-Formulare erstellen, ausfüllen, reduzieren und exportieren
  • Formularfeldverwaltung: Programmatischer Zugriff auf alle Formularfeldtypen
  • Anmerkungen: Hyperlinks und andere PDF-Anmerkungen hinzufügen

Grafiken und visuelle Elemente

  • Zeichenoperationen: Text, Bilder und Vektorgrafiken hinzufügen
  • Formen und Pfade: Erstellen Sie komplexe Vektorgrafiken
  • Wasserzeichen: Text- und Bildwasserzeichen anwenden
  • Inhaltsgruppen: Inhalte in logische Gruppen organisieren

GemBox.Pdf Code Beispiel: PDF-Bearbeitung und Formulare

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

Dieses Beispiel zeigt die Stärken von GemBox.Pdf in der PDF-Bearbeitung auf niedriger Ebene und demonstriert die Erstellung von Formularen, das Zeichnen von Grafiken und die Dokumentensicherheitsfunktionen. Während der Code ausführlicher ist als der HTML-Ansatz von IronPDF, bietet er die präzise Kontrolle über jeden Aspekt des PDFs.

Wie gehen diese Bibliotheken mit der Konvertierung von HTML in PDF um?

Der Ansatz zur HTML-zu-PDF-Konvertierung stellt einen der bedeutendsten Unterschiede zwischen IronPDF und GemBox.Pdf dar.

IronPDFs HTML-zu-PDF-Ansatz

IronPDF wurde von Grund auf mit dem Hauptfokus auf die HTML zu PDF-Konvertierung entwickelt. Die Bibliothek enthält eine vollständige Chrome-Rendering-Engine, die HTML, CSS und JavaScript genau so verarbeitet, wie es ein Webbrowser tun würde. Das bedeutet:

  • Echtes Browser-Rendering: Nutzt dieselbe Blink-Engine wie Google Chrome
  • Vollständige Unterstützung der Webstandards: Volle Unterstützung für CSS3, HTML5, Flexbox, Grid und modernes JavaScript
  • Dynamischer Inhalt: Führt JavaScript vor dem Rendern aus und erfasst so AJAX-Inhalte und dynamische Elemente.
  • Responsives Design: Unterstützt Media Queries und responsive Layouts
  • Externe Ressourcen: Lädt automatisch Bilder, Stylesheets und Schriftarten von URLs ab

GemBox's begrenzte HTML-Unterstützung

GemBox.Pdf unterstützt selbst keine HTML zu PDF-Konvertierung. Um HTML in PDF mit GemBox zu konvertieren, müssen Entwickler:

  1. GemBox.Document separat kaufen ($890 zusätzliche Kosten)
  2. GemBox.Document verwenden, um HTML in DOCX zu konvertieren
  3. Dann DOCX in PDF konvertieren

Dieser Ansatz hat erhebliche Einschränkungen:

  • Keine JavaScript Unterstützung: Dynamische Inhalte können nicht verarbeitet werden
  • Eingeschränkte CSS-Unterstützung: Viele moderne CSS-Funktionen werden nicht unterstützt.
  • Gestaltungsprobleme: Bekannte Probleme mit Rahmen und komplexen Layouts, wie in Stack Overflow-Diskussionen erwähnt.
  • Nur für den Druck optimiert: Erfordert speziell für den Druck formatiertes HTML.
  • Zusätzliche Kosten: Erfordert den Kauf von zwei separaten Bibliotheken

Moderne CSS-Framework-Unterstützung: Ein entscheidender Unterschied

Einer der bedeutendsten Vorteile von IronPDFs Chrome-basiertem Rendering wird sichtbar, wenn mit modernen CSS-Frameworks wie Bootstrap, Tailwind CSS und Foundation gearbeitet wird. Diese Frameworks sind das Rückgrat moderner Webanwendungen geworden, und ihre Fähigkeit, korrekt in PDFs dargestellt zu werden, ist für viele Anwendungsfälle unerlässlich.

IronPDF: Vollständige Unterstützung moderner Frameworks

IronPDFs Chrome-Rendering-Engine bietet vollständige, native Unterstützung für alle modernen CSS-Frameworks:

  • Bootstrap 5: Volle Flexbox- und CSS-Grid-Unterstützung für responsive Layouts
  • Tailwind CSS: Vollständige Unterstützung für Utility-First-CSS-Frameworks
  • Beispiele aus der Praxis: Rendert die Bootstrap-Homepage und Bootstrap-Vorlagen pixelgenau.
  • Moderne CSS3-Funktionen: Animationen, Transformationen, Übergänge, benutzerdefinierte Eigenschaften
  • Responsive Designs: Media Queries und Viewport-basierte Layouts funktionieren nahtlos.

Code-Beispiel: Bootstrap-Formular zu 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: Keine Unterstützung für moderne Frameworks

Da GemBox.Pdf kein natives HTML-Rendering unterstützt und auf GemBox.Document für die HTML-Konvertierung angewiesen ist, stoßen moderne CSS-Frameworks auf schwerwiegende Einschränkungen:

  • Keine Bootstrap-Unterstützung: Flexbox- und CSS-Grid-Funktionen werden nicht korrekt dargestellt.
  • Kein Tailwind CSS: Hilfsklassen und moderne Layouts werden nicht unterstützt
  • Manuelle Umgehungslösungen erforderlich: Es müssen druckoptimierte HTML-Versionen erstellt werden.
  • Eingeschränktes CSS3: Viele moderne CSS-Funktionen funktionieren einfach nicht.
  • Zusätzliche Komplexität: Der zweistufige Konvertierungsprozess (HTML → DOCX → PDF) führt zu Inkonsistenzen

Laut Entwicklerdiskussionen können selbst grundlegende CSS-Funktionen wie Rahmen und Layouts mit dem HTML-Konvertierungsansatz von GemBox problematisch sein.

Auswirkungen in der Praxis: Wenn Ihre Anwendung Bootstrap für ihre Benutzeroberfläche verwendet und Sie PDF-Berichte oder -Exporte generieren müssen, die zu Ihrer Weboberfläche passen, bietet IronPDF eine unkomplizierte Lösung, während GemBox umfangreiche Umgestaltungen oder manuelle Workarounds erfordern würde.

Für weitere Details zur Kompatibilität von CSS-Frameworks siehe den Bootstrap- & Flexbox-CSS-Leitfaden.

Welche Bibliothek eignet sich besonders gut für verschiedene PDF-Aufgaben?

Zu verstehen, wo jede Bibliothek glänzt, hilft Entwicklern, das richtige Werkzeug für ihre spezifischen Bedürfnisse zu wählen.

Wo IronPDF sich auszeichnet

IronPDF zeigt überlegene Leistung in diesen Szenarien:

1. PDF-Erzeugung für Webanwendungen

Perfekt für SaaS-Anwendungen, Webportale und jedes System, das Webinhalte in PDF umwandeln muss. Die Chrome-Rendering-Engine stellt sicher, dass komplexe Weblayouts, einschließlich solcher, die Bootstrap, Tailwind CSS oder benutzerdefinierte Frameworks verwenden, perfekt dargestellt werden.

2. Dynamische Berichterstellung

Wenn Berichte Diagramme (Chart.js, D3.js), dynamische Datenvisualisierungen oder von JavaScript gerenderte Inhalte enthalten, erfasst IronPDF alles genau. Das macht es ideal für Geschäftsintelligenz-Dashboards und datengesteuerte Anwendungen.

3. Rechnungs- und Dokumentenvorlagen

Durch die Verwendung von HTML/CSS-Vorlagen für Rechnungen, Quittungen und Geschäftsdokumente können Designer Vorlagen erstellen, ohne PDF-spezifische APIs erlernen zu müssen. Änderungen können schnell mithilfe vertrauter Webtechnologien vorgenommen werden.

4. Schnelle Entwicklungsprojekte

Die einfache API und der HTML-basierte Ansatz verkürzen die Entwicklungszeit erheblich. Ein Entwickler kann ein komplexes PDF in Minuten statt Stunden erstellen.

5. Bereitstellung auf verschiedenen Plattformen

Mit nativer Unterstützung für Windows, Linux, macOS, Docker und Cloud-Plattformen vereinfacht IronPDF die Bereitstellung in unterschiedlichen Umgebungen.

Wo GemBox.Pdf sich auszeichnet

GemBox.Pdf zeigt seine Stärken in diesen Bereichen:

1. Manipulation von PDFs auf niedriger Ebene

Wenn eine präzise Kontrolle über die PDF-Struktur erforderlich ist, bietet der objektorientierte Ansatz von GemBox.Pdf direkten Zugriff auf PDF-Elemente, Streams und Wörterbücher.

2. Formularlastige Anwendungen

Für Anwendungen, die umfangreich mit PDF-Formularen arbeiten, bietet GemBox.Pdf umfassende Manipulationsmöglichkeiten für Formularfelder, einschließlich der programmatischen Erstellung komplexer interaktiver Formulare.

3. OCR-Anforderungen

Mit eingebauten OCR-Funktionen kann GemBox.Pdf Text aus gescannten Dokumenten extrahieren, ohne zusätzliche Bibliotheken zu benötigen, was es für die Digitalisierung von Dokumenten geeignet macht.

4. Mobile Entwicklung

Die native Unterstützung von Android- und iOS-Plattformen macht GemBox.Pdf zu einer guten Wahl für mobile Anwendungen, die PDF-Funktionalität benötigen.

5. Bestehende PDF-Modifikation

Beim primären Arbeiten mit bestehenden PDFs anstatt neuer Generierung sind die Tools von GemBox.Pdf zum Extrahieren, Bearbeiten und Bearbeiten gut für die Aufgabe geeignet.

Wie lassen sich Installation und Einrichtung vergleichen?

Beide Bibliotheken bieten eine einfache Installation über NuGet, allerdings mit unterschiedlichen Komplexitätsstufen.

Installation von IronPDF

Die Installation von IronPDF ist bemerkenswert einfach:

Install-Package IronPdf

Oder über die .NET CLI:

dotnet add package IronPdf

Das Paket enthält alles Notwendige, einschließlich der Chrome-Rendering-Engine. Für die meisten Anwendungsfälle ist keine zusätzliche Konfiguration oder Abhängigkeit erforderlich.

Für spezifische Bereitstellungsszenarien bietet IronPDF:

  • IronPdf.Slim: Leichtgewichtiges Paket, das plattformspezifische Komponenten zur Laufzeit herunterlädt
  • IronPdf.Linux: Vorkonfiguriert für Linux-Bereitstellungen
  • IronPdf.MacOs: Optimiert für macOS-Umgebungen

Installation von GemBox.Pdf

Die Installation von GemBox.Pdf ist für die grundlegende PDF-Bearbeitung ebenso einfach:

Install-Package GemBox.Pdf

Für die HTML zu PDF-Konvertierung benötigen Sie jedoch:

Install-Package GemBox.Document

Beide Bibliotheken erfordern die Konfiguration des Lizenzschlüssels:

// 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

Was sind die Unterschiede in der Lizenzierung und Preisgestaltung?

Das Verständnis der Lizenzierungsmodelle hilft dabei, die Gesamtkosten für jede Lösung zu bestimmen.

IronPDF-Lizenzierung

IronPDF bietet transparente, gestaffelte Lizenzierung (Preise ab 2025):

  • Lite -Lizenz: $999

    • 1 Entwickler
    • 1 Projekt
    • 1 Jahr Support und Updates

  • Plus -Lizenz: $1,499

    • 3 Entwickler
    • 3 Projekte
    • 1 Jahr Support und Updates
  • Professional : $2,999
    • 10 Entwickler
    • 10 Projekte
    • 1 Jahr Support und Updates

Zusatzoptionen:

  • Lizenzfreie Weiterverbreitung: +$2,999
  • SaaS/OEM-Lizenzierung verfügbar
  • Iron Suite -Bundle : $1,498 für 9 Produkte

Wichtigste Vorteile:

  • 30-Tage-Geld-zurück-Garantie
  • Unbefristete Lizenzen (Einmalkauf)
  • Kostenlose Entwicklung und Testung
  • Bereitstellung für Entwicklungs-/Staging-/Produktion

GemBox.Pdf Lizenzierung

GemBox bietet Lizenzierung pro Entwickler:

  • Einzelentwickler: 890 $
    • 1 Entwickler
    • Unbegrenzte Projekte
    • 1 Jahr Support und Updates
    • Lizenzgebührenfreie Bereitstellung inbegriffen

Wichtige Überlegungen:

  • HTML zu PDF erfordert GemBox.Document: Zusätzliche $890
  • Gesamtkosten für HTML zu PDF: Mindestens $1,780
  • 40% Rabatt auf Verlängerungen (60% bei Verlängerung vor Ablauf)
  • GemBox Bundle: $2,200 für 7 Produkte

Wichtigste Vorteile:

  • 30-Tage-Geld-zurück-Garantie
  • Unbefristete Lizenzen
  • Unbegrenzte Bereitstellung inbegriffen
  • Keine Server- oder OEM-Lizenzen erforderlich

Kostenvergleich für gängige Szenarien

Szenario IronPDF Kosten GemBox Kosten
Einzelentwickler, HTML zu PDF $999 $1,780
3 Entwickler, nur PDF-Bearbeitung $1,499 $2,670
3 Entwickler, HTML zu PDF $1,499 $5,340
Unternehmen (10 Entwickler), volle Funktionen $2,999 $8,900+

Welche Bibliothek sollten Sie wählen?

Die Wahl zwischen IronPDF und GemBox.Pdf hängt von Ihren spezifischen Anforderungen ab:

Wählen Sie IronPDF, wenn:

Die Konvertierung von HTML zu PDF ist eine Grundvoraussetzung: Die Chrome-basierte Darstellung von IronPDF ist unübertroffen.

  • Sie benötigen moderne Webunterstützung: Volle CSS3-, HTML5- und JavaScript Fähigkeiten
  • Schnelle Entwicklung ist wichtig: Eine einfache API verkürzt die Markteinführungszeit.
  • Sie arbeiten mit dynamischen Inhalten: Die JavaScript Ausführung erfasst Echtzeitdaten
  • Plattformübergreifende Bereitstellung erforderlich: Hervorragende Unterstützung für Cloud- und Containerumgebungen
  • Das Budget spielt eine Rolle: Geringere Einstiegskosten und besseres Preis-Leistungs-Verhältnis bei HTML-zu-PDF-Szenarien.

Wählen Sie GemBox.Pdf wenn:

  • Eine detaillierte PDF-Kontrolle ist unerlässlich: Direkter Zugriff auf PDF-Objekte und -Struktur
  • Unterstützung der mobilen Plattform erforderlich: Native Android- und iOS-Kompatibilität
  • OCR ist eine Kernanforderung: Integrierte OCR ohne zusätzliche Abhängigkeiten
  • Sie arbeiten hauptsächlich mit bestehenden PDFs: Starke Bearbeitungs- und Extraktionsfunktionen Die Konvertierung von HTML zu PDF ist nicht erforderlich: Vermeiden Sie die Kosten für ungenutzte GemBox.Document-Dokumente.
  • Uneingeschränkte Bereitstellung ist wichtig: Lizenzgebührenfreie Weiterverbreitung inklusive

Die Verwendung beider Bibliotheken ist zu erwägen, wenn:

Einige Organisationen finden Wert darin, beide Bibliotheken für verschiedene Teile ihrer Anwendung zu nutzen:

  • IronPDF für Berichtserstellung und HTML zu PDF-Konvertierung
  • GemBox.Pdf für Formularverarbeitung und PDF-Bearbeitung

Einstieg in die Bibliothek Ihrer Wahl

Beide Bibliotheken bieten kostenlose Testversionen, um ihre Fähigkeiten zu bewerten:

Probieren Sie IronPDF aus.

  1. Installieren Sie das NuGet-Paket
  2. Kein Lizenzschlüssel für die Entwicklung nötig
  3. Wasserzeichen erscheinen in PDFs im Testmodus
  4. Vollzugriff auf Funktionen während der Evaluierung

IronPDF kostenlose Testversion herunterladen

Probieren Sie GemBox.Pdf aus.

  1. Installieren Sie das NuGet-Paket
  2. Verwenden Sie ComponentInfo.SetLicense("FREE-LIMITED-KEY")
  3. Auf 2 Seiten im kostenlosen Modus beschränkt
  4. Upgrade zur Beseitigung von Beschränkungen

Visuelle Installationsanleitung

Für Entwickler, die die grafische Benutzeroberfläche von Visual Studio bevorzugen, hier eine Schritt-für-Schritt-Anleitung zur Installation beider Bibliotheken:

Ein neues ASP.NET-Projekt erstellen

Visual Studio-Dialogfeld Der Neue-Projekt-Dialog von Visual Studio für die Erstellung einer ASP.NET-Webanwendung - die Grundlage für PDF-Generierungsprojekte

Auswahlbildschirm für ASP.NET Projektvorlagen mit Hervorhebung der Web Forms-Option für die PDF-Bibliotheksintegration Die Auswahl von Webformularen als Projektvorlage - geeignet für sowohl IronPDF- als auch GemBox.Pdf-Implementierungen

Installation von PDF-Bibliotheken über NuGet

Das Kontextmenü des Projektmappen-Explorers zeigt die Option Klicken Sie mit der rechten Maustaste auf Ihr Projekt im Lösungs-Explorer, um den NuGet-Paketmanager für die Bibliotheksinstallation aufzurufen

Visual Studio-Projektmenü mit der Option Alternative Zugang zum NuGet-Paketmanager über das Projektmenü in Visual Studio

Benutzeroberfläche des NuGet Paketmanagers mit Anzeige der IronPDF Installation mit Versionsdetails und Beschreibung IronPDF über den NuGet-Paketmanager installieren - beachten Sie die umfassende Funktionsbeschreibung und die Download-Anzahl

Alternative Installationsmethoden

Offizielle IronPDF -Website-Downloadseite mit direkter DLL-Download-Option für die manuelle Installation Die Webseite von IronPDF bietet direkte DLL-Downloads für Szenarien, in denen die NuGet-Installation nicht geeignet ist

Abschluss

Sowohl IronPDF als auch GemBox.Pdf sind hochwertige PDF-Bibliotheken für .NET-Entwickler, jede mit eigenen Stärken. IronPDF glänzt in der HTML zu PDF-Konvertierung mit seiner Chrome-Rendering-Engine, was es ideal für moderne Webanwendungen und die Erstellung dynamischer Inhalte macht. GemBox.Pdf glänzt in der PDF-Bearbeitung auf niedriger Ebene und mit mobiler Unterstützung, perfekt für Anwendungen, die eine präzise PDF-Kontrolle erfordern.

Für die meisten Webentwickler und Teams, die moderne Anwendungen erstellen, bietet IronPDF die beste Kombination aus Funktionen, Benutzerfreundlichkeit und Preis-Leistungs-Verhältnis. Seine Fähigkeit, pixelgenaue PDFs aus HTML mithilfe vertrauter Webtechnologien zu erzeugen, verkürzt Entwicklungszeit und Komplexität erheblich.

GemBox.Pdf bleibt jedoch eine solide Wahl für spezialisierte Szenarien, insbesondere für die mobile Entwicklung und Anwendungen, die sich auf die PDF-Formularverarbeitung oder OCR-Anforderungen konzentrieren.

Bereit, Ihre HTML-Inhalte in professionelle PDFs zu verwandeln? Starten Sie mit der kostenlosen Testversion von IronPDF und erleben Sie die Leistung von Chrome-Rendering in Ihren .NET-Anwendungen. Mit umfassender Dokumentation, umfassenden Codebeispielen und reaktionsschnellem Support erstellen Sie PDFs in Minuten, nicht Stunden.

Hinweis:GemBox.Pdf und GemBox.Document sind eingetragene Marken ihrer jeweiligen Inhaber. Diese Seite ist nicht mit GemBox.Pdf oder GemBox.Document verbunden, wird nicht von diesen unterstützt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

Häufig gestellte Fragen

Wie kann ich HTML in PDF in C# konvertieren?

Sie können die RenderHtmlAsPdf-Methode von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren. Sie können auch HTML-Dateien mit RenderHtmlFileAsPdf in PDFs konvertieren.

Kann ich vorhandene PDF-Dateien mit diesen Bibliotheken manipulieren?

Ja, sowohl IronPDF als auch GemBox.Pdf können verwendet werden, um vorhandene PDF-Dateien zu manipulieren. IronPDF vereinfacht häufige Aufgaben wie das Zusammenführen, Aufteilen und Hinzufügen von Wasserzeichen. GemBox.Pdf bietet eine detailliertere Kontrolle über PDF-Objekte, was für komplexe Manipulationsaufgaben nützlich ist.

Was sind die Vorteile der Nutzung von IronPDF für die HTML-zu-PDF-Konvertierung?

IronPDF bietet überlegene Konvertierungsqualität von HTML zu PDF mit seiner Chrome V8-Rendering-Engine und erreicht über 98 % Browser-Treue. Es unterstützt moderne CSS3-, HTML5-, JavaScript-Ausführung, Web-Schriften und responsive Designs.

Welche Bibliothek ist kostengünstiger für ein kleines Entwicklungsteam?

Für ein 3-Entwickler-Team, das HTML-zu-PDF-Konvertierung benötigt, kostet IronPDF $1.499 für die Plus-Lizenz, während GemBox $5.340 für 3 GemBox.Pdf-Lizenzen und 3 GemBox.Document-Lizenzen kosten würde. IronPDF bietet deutlich besseren Wert für Teams.

Ist IronPDF geeignet für die Erzeugung von PDFs in großen Mengen?

Ja, IronPDF bietet hervorragende Leistung mit einer ungefähren HTML-zu-PDF-Rendering-Zeit von 125 ms, optimierter async/await-Unterstützung und effizienter Speichernutzung unter 10 MB. Es ist gut geeignet für die Erzeugung von web-basierten PDFs in großen Mengen.

Welche Art von Support ist bei IronPDF enthalten?

IronPDF umfasst 24/5 Ingenieur-Support mit direktem Zugang zum Entwicklungsteam und typischen Reaktionszeiten von 24-48 Stunden sowie umfassender Dokumentation und Codebeispielen.

Kann ich PDF/A-konforme Dokumente mit diesen Bibliotheken erstellen?

Ja, IronPDF kann PDF/A-konforme Dokumente mit einem einfachen Methodenaufruf wie SaveAsPdfA() generieren und unterstützt mehrere PDF/A-Versionen. GemBox.Pdf kann PDF/A-Dokumente lesen und die Konformität bei deren Modifikation beibehalten.

Sind diese Bibliotheken mit modernen .NET-Frameworks kompatibel?

Ja, beide Bibliotheken unterstützen moderne .NET-Versionen. IronPDF unterstützt .NET Framework 4.6.2+, .NET Core 3.1+ und .NET 5 bis 10. GemBox.Pdf unterstützt .NET Framework 3.5+, .NET Standard 2.0 und .NET 6+.

Welche Bibliothek ist für den Einsatz in der Cloud optimiert?

IronPDF ist für den Cloud-Einsatz optimiert mit spezifischer Unterstützung für Azure, AWS, Docker-Container und serverlose Umgebungen. Sein HTML-basierter Ansatz passt sich natürlich an Webanwendungen an, was es zur besseren Wahl für SaaS-Anwendungen macht.

Gibt es eine kostenlose Version für das Testen von IronPDF?

IronPDF bietet eine kostenlose Evaluationsoption, die unbegrenzte Entwicklung und Tests ohne Lizenzschlüssel ermöglicht, obwohl Wasserzeichen auf den Ausgaben erscheinen. Dies bietet genügend Funktionalität, um das Produkt vor dem Kauf zu bewerten.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an