PRODUKTVERGLEICHE

IronPDF vs EvoPdf: Welche .NET PDF-Bibliothek liefert im Jahr 2025 mehr Wert?

Q: Wie kann ich HTML in PDF in C# mit einer .NET-Bibliothek 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.

Jacob Mellor

Aktualisiert:18. Januar 2026

Beim Erstellen moderner .NET-Anwendungen, die PDF-Funktionalität erfordern, kann die Wahl der richtigen Bibliothek Ihre Entwicklungsgeschwindigkeit, die Anwendungsleistung und die langfristigen Wartungskosten erheblich beeinflussen. IronPDF und EvoPdf stellen zwei unterschiedliche Ansätze zur PDF-Erstellung und -Manipulation im .NET-Ökosystem dar, die jeweils mit einzigartigen Stärken aufwarten, die auf verschiedene Entwicklungsszenarien zugeschnitten sind.

Dieser umfassende Vergleich untersucht beide Bibliotheken über kritische Dimensionen hinweg, einschließlich der Genauigkeit der Wiedergabe, des API-Designs, der Leistungskennzahlen, der Plattformkompatibilität und der Gesamtkosten des Besitzes. Egal, ob Sie ein Hochvolumen-Dokumentverarbeitungssystem aufbauen, digitale Signaturen zur Einhaltung von Vorschriften implementieren oder einfach HTML-Berichte in PDF konvertieren, das Verständnis dieser Unterschiede wird Ihnen helfen, eine fundierte Entscheidung zu treffen, die Ihrer technischen Anforderungen und Budgetbeschränkungen entspricht.

Wie lassen sich IronPDF und EvoPdf auf einen Blick vergleichen?

Bevor wir in detaillierte Vergleiche eintauchen, hier ist eine umfassende Übersicht darüber, wie sich diese Bibliotheken in den wichtigsten Kategorien, die für .NET-Entwickler am relevantesten sind, vergleichen:

Überblick über den Produktvergleich

Vergleich von IronPDF und EvoPdf for .NET PDF Generation

Kategorie	Merkmal/Aspekt	IronPDF	EvoPdf	Hauptvorteil
Kernarchitektur	Design-Philosophie	Intuitive APIs, die auf Einfachheit setzen	Leistungsstarker, traditioneller PDF-Ansatz	IronPDF: Schnellere Entwicklung
	API-Komplexität	Einfache Methoden wie `RenderHtmlAsPdf()`	Mehrklassenansatz mit mehr Setup	IronPDF: 60 % weniger Code
	Lernkurve	typisch 1-2 Tage	3-5 Tage typisch	IronPDF: Schnellere Akzeptanz
Plattform-Unterstützung	Plattformübergreifend	Native Unterstützung, keine zusätzliche Konfiguration	Erfordert eine plattformspezifische Einrichtung	IronPDF: Einfachere Bereitstellung
	.NET-Versionen	.NET 10, 9, 8, 7, 6, 5, Core 3.1+, Framework 4.6.2+	.NET 8, 7, 6, 5, Standard 2.0+, Framework 4.0+	Beides: Unterstützung moderner Frameworks
	Betriebssysteme	Windows, Linux, macOS, Docker nativ	Windows, Linux, macOS, Azure	IronPDF: Docker-optimiert
HTML zu PDF	Rendering-Engine	Vollständige Chrome V8-Engine	Benutzerdefinierte HTML-Rendering-Engine	IronPDF: 98%+ Browser-Treue
	CSS3/HTML5-Unterstützung	Vollständige Unterstützung	Gute Unterstützung (90% Abdeckung)	IronPDF: Moderne Webstandards
	JavaScript-Ausführung	Volle JavaScript-Unterstützung mit Wartezeit	Gute JavaScript-Unterstützung	IronPDF: Bereit für dynamische Inhalte
	Rendering-Geschwindigkeit	1.2-1,8s typisch (komplexe Seiten)	0.8-1.2s typisch	EvoPdf: Schneller für einfaches HTML
Security & Encryption	Verschlüsselungsstufen	AES-256, benutzerdefinierte Handler	AES-256-Standard	Beides: Industriestandard
	Optionen für die Erlaubnis	15+ granulare Berechtigungen	8 Standardberechtigungen	IronPDF: Bessere Kontrolle
	Digitale Signaturen	Integrierte, visuelle Signaturen	Grundlegende Unterstützung für Signaturen	IronPDF: Einfachere Unterzeichnung
Inhaltsmanipulation	Redaktionsmethode	Echte Inhaltsentfernung, einzeilige API	Keine integrierte Schwärzung	IronPDF: Compliance-gerecht
	Wasserzeichen	HTML/CSS-basiert, vollständiges Styling	Vorlagenbasierte Wasserzeichen	IronPDF: Reichhaltige Wasserzeichen
	Stempeln	Vereinheitlichte Stamper-Klassen	Gleiche Funktion wie Wasserzeichen	IronPDF: Dedizierte Werkzeuge
Datei-Konvertierungen	DOCX to PDF	Eingebauter `DocxToPdfRenderer`	Erfordert Evo Word to PDF ($450)+)	IronPDF: Keine zusätzlichen Kosten
Erfahrung des Entwicklers	Codebeispiele	100+ fertige Beispiele	50+ Beispiele	IronPDF: Umfangreiche Ressourcen
	Dokumentation	Tutorials, Anleitungen, Videos, API-Referenz	API-Dokumente und Beispiele	IronPDF: Mehrere Lernpfade
	Fehlermeldungen	Beschreibend, umsetzbar	Standard-Fehlerberichterstattung	IronPDF: Bessere Fehlersuche
Leistungskennzahlen	Verarbeitung großer Dokumente	1000 Seiten/Min. Wasserzeichen	700 Seiten/Min. Wasserzeichen	IronPDF: 30% schneller
	Threading-Unterstützung	Natives async/await optimiert	Multi-Threading-Unterstützung	IronPDF: Bessere Skalierbarkeit
Licensing & Pricing	Einstiegsstufe	Lite: $999 (1 dev, 1 project)	Bereitstellung: $450 (1 Server, 1 Anwendung)	EvoPdf: Niedrigere Anfangskosten
	Teamlizenz	Plus: 1.499 $ (3 Entwickler, 3 Projekte)	Unternehmen: $1,200 (unbegrenzte Anzahl von Entwicklern)	EvoPdf: Besser für große Teams
	Weitervertrieb	+$1.999 lizenzgebührenfrei	In der Unternehmenslizenz enthalten	EvoPdf: Eingebaute Weiterverbreitung
	Suite-Option	Iron Suite: $1,498 (9 products)	EVO PDF-Toolkit: 1.400 Euro	IronPDF: Weitere enthaltene Produkte
Unterstützung	Inklusive Unterstützung	Ja, 24/5 technische Unterstützung	Ja, Standard-Support im ersten Jahr	IronPDF: Direkter technischer Zugang
Best für	Anwendungsfälle	Moderne Webanwendungen, komplexe PDFs, Compliance	Einfache Konvertierung von HTML in PDF, einfache Konvertierung	Kontextabhängig

*Hinweis.* EvoPdf bietet wettbewerbsfähige Preise für große Teams, verfügt aber nicht über einige fortgeschrittene Funktionen, wie z. B. Redigieren. IronPDF bietet eine umfassendere Funktionalität mit integrierter Unterstützung für die Dokumentenkonvertierung.

Unterstanding IronPDF and EvoPdf: Hauptstärken und Philosophie

Was zeichnet IronPDF auf dem Markt für .NET PDF-Bibliotheken aus?

IronPDF stellt eine umfassende PDF-Lösung dar, die mit der Produktivität der Entwickler im Mittelpunkt entwickelt wurde. Auf einer Grundlage der Einfachheit, ohne an Leistung zu sparen, ermöglicht IronPDF for .NET-Entwicklern die Erstellung, Bearbeitung und Manipulation von PDF-Dokumenten mit intuitiven APIs, die vertrauten Mustern der Webentwicklung entsprechen. Das herausragende Merkmal der Bibliothek ist ihre auf Chrome basierende Rendering-Engine, die eine pixelgenaue HTML-zu-PDF-Konvertierung gewährleistet, während sie die neuesten Webstandards einschließlich CSS3, JavaScript-Frameworks und Webfonts unterstützt.

Die Bibliothek überzeugt in Szenarien, die hochpräzises Dokumenten-Rendering, komplexe PDF-Manipulationen und unternehmensgerechte Sicherheitsfunktionen erfordern. Ihr umfangreiches Funktionsset umfasst nicht nur grundlegende PDF-Erstellung, sondern auch erweiterte Funktionen wie digitale Signaturen, Formularausfüllung, OCR-Integration durch IronOCR und nahtlose Dokumentformatkonvertierungen. IronPDFs plattformübergreifende Kompatibilität geht über einfache Framework-Unterstützung hinaus und bietet native Leistung auf Windows, Linux, macOS, Docker-Containern und Cloud-Plattformen wie Azure und AWS.

Wie unterscheidet sich der Ansatz von EvoPdf bei der PDF-Erzeugung?

EvoPdf verfolgt einen traditionelleren Ansatz bei der PDF-Manipulation und konzentriert sich in erster Linie auf die HTML-zu-PDF-Konvertierung mit einem Schwerpunkt auf Anpassung und Kontrolle. Die Bibliothek bietet Entwicklern eine feingranulare Kontrolle über den Konvertierungsprozess und ermöglicht das Feinabstimmen der Rendering-Parameter, Seitenlayout und Konvertierungseinstellungen. Die Architektur von EvoPdf zielt auf zuverlässige, konsistente Ergebnisse für Standard-Web-zu-PDF-Konvertierungsszenarien ab.

EvoPdf glänzt insbesondere durch seinen geringen Ressourcenbedarf und eine schnellere Rendering-Geschwindigkeit für einfache HTML-Dokumente. Für einfache HTML-Seiten ohne komplexes JavaScript oder CSS3-Features kann EvoPdf Konvertierungen in 0,8-1,2 Sekunden abschließen, was es geeignet für die Massenverarbeitung von unkomplizierten Dokumenten macht. Die Bibliothek bietet auch gute Unterstützung für serverseitiges Rendering in ASP.NET-Umgebungen mit Optimierungen für Web-Anwendungsszenarien.

Wie lassen sich die plattformübergreifenden Fähigkeiten der einzelnen Bibliotheken vergleichen?

IronPDFs moderne plattformübergreifende Architektur

IronPDF bietet nahtlose plattformübergreifende Kompatibilität, die über einfache Framework-Unterstützung hinausgeht. Die Bibliothek arbeitet nativ auf:

.NET-Version Unterstützung:

.NET 10, 9, 8, 7, 6, 5 und Core 3.1+
.NET Standard 2.0+
.NET Framework 4.6.2+
Volle Unterstützung für C#, VB.NET und F#

Betriebssystemkompatibilität:

Windows (x86, x64, ARM)
Linux (Ubuntu, Debian, CentOS, Alpine)
macOS (Intel und Apple Silicon)
Docker-Container mit vorkonfigurierten Images

Cloud Plattform Integration:

Azure App Service, Functions und VMs
AWS Lambda und EC2
Google Cloud Platform
Kubernetes-Bereitstellungen

Was IronPDF auszeichnet, ist sein Zero-Configuration-Bereitstellungsmodell. Anders als viele PDF-Bibliotheken, die zusätzliche Abhängigkeiten oder Laufzeiteinrichtungen erfordern, enthält IronPDF alle notwendigen Komponenten innerhalb des NuGet-Pakets. Dieser eigenständige Ansatz reduziert die Bereitstellungskomplexität erheblich und beseitigt häufige "works on my machine"-Probleme.

EvoPdfs Plattformanforderungen und -beschränkungen

EvoPdf unterstützt eine ähnliche Reihe von .NET-Versionen, erfordert jedoch eine sorgfältigere Konfiguration für plattformübergreifende Szenarien:

.NET Framework Unterstützung:

.NET 8, 7, 6 und 5
.NET Standard 2.0+
.NET Framework 4.8.1, 4.7.2, 4.6.1 und 4.0+

Plattformerwägungen:

Primär optimiert für Windows-Umgebungen
Linux-Unterstützung erfordert zusätzliche Konfiguration
macOS-Unterstützung durch .NET Core
Cloud-Bereitstellungen benötigen plattformspezifische Anpassungen

Für plattformübergreifende Bereitstellungen müssen EvoPdf-Benutzer häufig plattformspezifische Abhängigkeiten und Konfigurationen handhaben, insbesondere beim Wechsel zwischen Windows- und Linux-Umgebungen. Diese zusätzliche Setup-Komplexität kann Entwicklungstermine beeinträchtigen und den Wartungsaufwand erhöhen.

Welche Bibliothek bietet die bessere PDF-Funktionalität für gängige Aufgaben?

HTML zu PDF Konvertierung: Rendering-Qualität und Leistung

Die grundlegendste Funktion beider Bibliotheken ist die HTML zu PDF-Konvertierung, jedoch unterscheiden sich ihre Ansätze und Ergebnisse erheblich.

IronPDF HTML zu PDF Beispiel

using IronPdf;

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

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

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

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

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

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

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

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

using IronPdf;

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

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

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

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

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

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

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

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

Imports IronPdf

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

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

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

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

$vbLabelText $csharpLabel

Dieses IronPDF-Beispiel zeigt mehrere erweiterte Funktionen:

Chrome V8 JavaScript -Engine: Führt Chart.js vollständig aus, um dynamische Visualisierungen zu rendern
Unterstützung für Webfonts: Lädt Google Fonts automatisch herunter und bettet sie ein.
Responsives Rendering: Berücksichtigt CSS-Media-Queries zur Druckoptimierung
Unterstützung hoher DPI-Auflösungen: Erzeugt druckfertige PDFs mit 300 DPI
Automatisches Layout: Passt den Inhalt intelligent an die Seitenränder an

EvoPdf HTML zu PDF Beispiel

using EvoPdf;

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

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

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

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

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

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

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

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

using EvoPdf;

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

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

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

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

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

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

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

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

Imports EvoPdf

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

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

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

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

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

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

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

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

$vbLabelText $csharpLabel

Der Ansatz von EvoPdf konzentriert sich auf die unkomplizierte HTML-Konvertierung mit guter Unterstützung für grundlegendes Styling und Layout. Während es Standard-HTML und CSS gut handhabt, kann es mit modernen Web-Features wie CSS Grid, Flexbox-Animationen oder komplexen JavaScript-Frameworks zu kämpfen haben.

PDF-Sicherheit und Verschlüsselung: Schutz sensibler Dokumente

Sicherheit ist beim Umgang mit vertraulichen Dokumenten von entscheidender Bedeutung. Beide Bibliotheken bieten Verschlüsselungsfunktionen, jedoch mit unterschiedlichen Ausprägungen der Raffinesse.

IronPDF Erweiterte Sicherheitsimplementierung

using IronPdf;
using IronPdf.Security;

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

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

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

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

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

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

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

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

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

pdf.Sign(signature);

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

pdf.SaveAs("secured-document.pdf");

using IronPdf;
using IronPdf.Security;

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

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

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

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

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

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

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

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

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

pdf.Sign(signature);

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

pdf.SaveAs("secured-document.pdf");

Imports IronPdf
Imports IronPdf.Security

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

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

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

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

pdf.Sign(signature)

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

pdf.SaveAs("secured-document.pdf")

$vbLabelText $csharpLabel

IronPDFs Sicherheitsimplementierung bietet Funktionen auf Unternehmensniveau:

Über 15 detaillierte Berechtigungen: Legen Sie genau fest, was Benutzer tun dürfen
Visuelle digitale Signaturen: Signaturbilder und Zeitstempel einbeziehen
Metadatenschutz: Sichere Dokumenteigenschaften und Prüfprotokolle
Mehrschichtige Sicherheit: Kombination von Verschlüsselung, Signaturen und Wasserzeichen

EvoPdf-Sicherheitskonfiguration

using EvoPdf;

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

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

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

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

using EvoPdf;

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

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

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

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

Imports EvoPdf

' Create security manager
Private securityOptions As New PdfSecurityOptions()

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

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

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

$vbLabelText $csharpLabel

EvoPdf bietet wesentliche Sicherheitsfunktionen für den grundlegenden Dokumentenschutz, es fehlen jedoch einige der erweiterten Optionen, die in IronPDF verfügbar sind.

Redaktion von Inhalten: Einhaltung von Vorschriften und Schutz der Privatsphäre

In der heutigen Datenschutz-Umgebung ist die Fähigkeit, vertrauliche Informationen dauerhaft aus PDFs zu entfernen, entscheidend für die Einhaltung von Vorschriften wie GDPR, HIPAA und CCPA.

IronPDF Redaction Beispiel

using IronPdf;

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

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

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

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

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

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

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

using IronPdf;

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

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

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

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

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

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

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

Imports IronPdf

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

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

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

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

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

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

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

$vbLabelText $csharpLabel

Die Redaktionsfähigkeiten von IronPDF umfassen:

Vollständige Inhaltsentfernung: Entfernt Text dauerhaft, nicht nur überdeckt.
Mustererkennung: Regex-Unterstützung für Sozialversicherungsnummern, Kreditkarten und E-Mails
Visuelle Schwärzungsstile: Anpassbares Erscheinungsbild für Prüfprotokolle
OCR-Integration: Text in gescannten Dokumenten schwärzen
Selektive Schwärzung: Bestimmte Seiten oder Bereiche gezielt schwärzen

EvoPdf enthält keine integrierte Redaktionsfunktionalität, was eine erhebliche Einschränkung für Anwendungen darstellen kann, die die Einhaltung von Datenschutzbestimmungen erfordern.

Formularbearbeitung: Interaktive PDFs erstellen

Beide Bibliotheken unterstützen PDF-Formulare, jedoch mit unterschiedlichen Ansätzen zur Erstellung und Manipulation.

IronPDF Forms Beispiel

using IronPdf;
using IronPdf.Forms;

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

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

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

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

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

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

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

var pdf = renderer.RenderHtmlAsPdf(html);

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

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

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

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

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

using IronPdf;
using IronPdf.Forms;

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

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

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

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

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

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

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

var pdf = renderer.RenderHtmlAsPdf(html);

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

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

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

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

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

Imports IronPdf
Imports IronPdf.Forms

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

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

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

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

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

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

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

Private pdf = renderer.RenderHtmlAsPdf(html)

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

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

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

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

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

$vbLabelText $csharpLabel

IronPDFs Formular-Handling-Funktionen:

Automatische Formulargenerierung: Konvertiert HTML-Formulare in PDF-Formulare
Programmatische Manipulation: Formularfelder über API ausfüllen, lesen und ändern
Feldtypen: Text-, Kontrollkästchen-, Optionsfeld-, Dropdown-, Unterschriftenfelder
Validierung: Feldeigenschaften und -beschränkungen festlegen
Formularvereinfachung: Ausgefüllte Formulare in statische PDFs umwandeln

Leistungsvergleiche: Real-World Scenarios

Die Leistungsmerkmale variieren erheblich je nach Dokumentenkomplexität und Anwendungsfall:

Test der Stapelverarbeitungsleistung

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

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

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

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

        await Task.WhenAll(tasks);

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

        // Memory usage
        var process = Process.GetCurrentProcess();
        Console.WriteLine($"Memory: {process.WorkingSet64 / 1024 / 1024}MB");
    }
}

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

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

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

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

        await Task.WhenAll(tasks);

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

        // Memory usage
        var process = Process.GetCurrentProcess();
        Console.WriteLine($"Memory: {process.WorkingSet64 / 1024 / 1024}MB");
    }
}

' Performance comparison for batch processing
Public Class PerformanceBenchmark
	Public Shared Async Function RunBenchmark() As Task
		Dim htmlTemplates = GenerateInvoiceTemplates(1000)
		Dim stopwatch As New Stopwatch()

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

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

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

		Await Task.WhenAll(tasks)

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

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

$vbLabelText $csharpLabel

Leistungsergebnisse aus realen Tests:

Einfaches HTML: EvoPdf ist 30-40 % schneller (0,8 s gegenüber 1,2 s)
Komplexes JavaScript: IronPDF ist zuverlässiger, EvoPdf kann ausfallen
Stapelverarbeitung: IronPDF – bessere Parallelisierung
Speichernutzung: EvoPDF niedrigerer Basiswert, IronPDF bessere Speicherbereinigung
Große Dokumente: IronPDF ist bei Dokumenten mit mehr als 1000 Seiten 30 % schneller.

Wie sehen die Preismodelle für verschiedene Teamgrößen aus?

IronPDF-Lizenzstruktur

IronPDF bietet verschiedene Preismodelle, darunter Lite-, Plus- und Professional-Lizenzen, mit der Option für lizenzfreie Weitervertrieb. Das Lizenzmodell ist so konzipiert, dass es mit Ihrem Team und Ihren Projektanforderungen skaliert (Preise ab 2025):

Lite -Lizenz: $999
- 1 Entwickler
- 1 Standort
- 1 Projekt
- E-Mail-Support
- Ideal für: Einzelne Entwickler, kleine Projekte
Plus Lizenz: $1,499
- 3 Entwickler
- 3 Standorte
- 3 Projekte
- E-Mail-, Chat- und Telefonsupport
- Ideal für: Kleine Teams, mehrere Projekte
Professional : $2,999
- 10 Entwickler
- 10 Standorte
- 10 Projekte
- Prioritätsunterstützung mit Bildschirmfreigabe
- Ideal für: Mittelgroße bis große Teams
Zusätzliche Optionen:
- Lizenzfreie Weiterverbreitung: +$2,999
- 5 Jahre Support und Updates: $1,999 (oder $999/Jahr)
- Iron Suite : $1,498 für alle 9 Iron Software Produkte

EvoPdf-Lizenzierungsoptionen

Das EVO PDF Toolkit kostet $650 für die Bereitstellungsversion und $1,400 für die Firmanversion, während der eigenständige HTML zu PDF-Konverter $450 für die Bereitstellung und $1,200 für die Firmanversion kostet:

Bereitstellungslizenz:
- EVO HTML zu PDF: $450
- EVO PDF Toolkit: $650
- Einzelner Server, einzelne Anwendung
- Kann nicht neu verteilt werden
- Standard-Support im ersten Jahr
Firmenlizenz:
- EVO HTML zu PDF: $1,200
- EVO PDF-Toolkit: 1.400 Euro
- Unbegrenzte Entwickler
- Unbegrenzte Bereitstellungen
- Vollständige Umverteilungsrechte
- Premium-Support im ersten Jahr

Total Cost of Ownership-Analyse

Lassen Sie uns reale Szenarien betrachten, um die tatsächlichen Kostenimplikationen zu verstehen:

Szenario 1: Startup mit 2 Entwicklern

IronPDF Lite: $999 (erfordert 2 Lizenzen = $1,498)
EvoPdf Company: $1,200 (deckt unbegrenzte Entwickler ab)
Gewinner: EvoPdf aufgrund der Anschaffungskosten

Szenario 2: Wachsendes Team (5 Entwickler, mehrere Projekte)

IronPDF Plus: $1,499 (deckt bis zu 3 Entwickler ab, Professional erforderlich)
IronPDF Professional: $2,999
EvoPdf Company: $1,200
Gewinner: EvoPdf für Team-Skalierung

Szenario 3: Unternehmen mit Bedarf an mehreren PDF-Tools

IronPDF Professional + IronOCR + IronBarcode: ~9.000 $
Iron Suite: $1,498 (alle 9 Produkte)
EvoPdf Toolkit + zusätzliche Tools: $1,400+ pro Werkzeug
Gewinner: Iron Suite für umfassende Bedürfnisse

Szenario 4: SaaS-Produkt mit Weitervertrieb

IronPDF Professional + Weitervertrieb: $4,998
EvoPdf Company: $1,200 (inklusive Weitervertrieb)
Gewinner: EvoPdf für Umverteilungsszenarien

Wie wirken sich moderne CSS-Frameworks auf Ihre Wahl aus?

Ein oft unterschätzter Faktor bei der Auswahl einer PDF-Bibliothek ist die Unterstützung moderner CSS-Frameworks. Mit Bootstrap, Tailwind CSS und Foundation, die die Webentwicklung dominieren, beeinflusst die Fähigkeit Ihrer Bibliothek, diese Frameworks zu unterstützen, direkt die Entwicklungseffizienz und die Qualität der Ergebnisse.

IronPDF: Umfassende Framework-Unterstützung

Die vollständige Chrome V8-Engine von IronPDF bietet native Unterstützung für alle modernen CSS-Frameworks ohne Kompromisse:

Bootstrap 5: Vollständige Flexbox- und CSS-Grid-Unterstützung für komplexe Layouts Tailwind CSS: Alle Utility-Klassen werden korrekt gerendert.
Modernes CSS3: Transformationen, Animationen, benutzerdefinierte Eigenschaften werden unterstützt
Produktionsvalidierung: Die Bootstrap-Startseite und die Bootstrap-Vorlagen werden erfolgreich gerendert.

Code-Beispiel: Bootstrap-Zeitachsenkomponente

using IronPdf;

var renderer = new ChromePdfRenderer();

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

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

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

using IronPdf;

var renderer = new ChromePdfRenderer();

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

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

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

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

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

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

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

$vbLabelText $csharpLabel

EvoPdf: Gute CSS-Unterstützung mit Einschränkungen

Der benutzerdefinierte HTML-Rendering-Engine von EvoPdf bietet solide CSS-Unterstützung mit einigen Einschränkungen für moderne Frameworks:

Bootstrap 3: Funktioniert im Allgemeinen gut mit älteren Bootstrap-Versionen
Bootstrap 4+: Flexbox-Layouts müssen möglicherweise angepasst werden
CSS3-Unterstützung: Gute Abdeckung (~90 %), aber nicht vollständig
Verfügbare Workarounds: Manuelle CSS-Anpassungen sind bei komplexen Layouts oft notwendig.

Praktische Überlegungen:

Laut Entwicklererfahrung:

Grundlegende Bootstrap-Komponenten (Buttons, Warnungen, Tabellen) rendern im Allgemeinen korrekt
Fortschrittliche Komponenten (Navigationsleisten, Modale, komplexe Grids) benötigen möglicherweise Anpassung
CSS-Grid-Layouts erfordern Testen und möglicherweise Fallbacks
Benutzerdefinierte Bootstrap-Themen haben manchmal unerwartete Wiedergabeprobleme

Auswirkungen auf die Entwicklung: Wenn Ihre Anwendung Bootstrap umfassend für die Benutzeroberfläche nutzt und Sie Berichte oder Dokumente generieren müssen, die Ihrer Weboberfläche entsprechen, spart das nahtlose Rendering von IronPDF erheblich Entwicklungszeit. EvoPdf erfordert möglicherweise die Erstellung separater, vereinfachter Versionen Ihrer Vorlagen speziell für die PDF-Generierung.

Für umfassende Informationen zur Kompatibilität von CSS-Frameworks finden Sie im Bootstrap & Flexbox CSS Guide.

Welche Dokumentations- und Supportoptionen sind für Entwickler besser geeignet?

IronPDFs Ressourcen für Entwickler

IronPDF bietet umfassende Dokumentation, 24/5-Ingenieursupport, Video-Tutorials, ein Community-Forum und regelmäßige Updates. Das Support-Ökosystem umfasst:

Qualität der Dokumentation:
Umfassende API-Referenz
Anleitungen Schritt für Schritt
100+ Code-Beispiele
Video-Tutorials auf YouTube
- Migrationsanleitungen von anderen Bibliotheken
Supportkanäle:
- 24/5-Ingenieur-Support (direkter Zugang zu Entwicklern)
- Antwortzeit: Typischerweise 24-48 Stunden
- Live-Chat für Plus+-Lizenzen
- Telefonsupport für Professional-Lizenzen
- Bildschirmfreigabe für komplexe Probleme
- Community-Forum und Stack-Overflow-Präsenz
Lernressourcen:
Erste Schritte Anleitungen
- Architekturdokumentation
- Leistungsoptimierungsanleitungen
- Sicherheitsbestes Praktiken
- Cloud-Bereitstellungsanleitungen

EvoPdfs Support-Struktur

EvoPdf bietet Dokumentation und Support durch:

Dokumentation:
- API-Referenzdokumentation
- Code-Beispiele für häufige Szenarien
- Live-Demo-Bereich auf der Website
- Grundlegende Fehlerbehebungsanleitungen
Support-Optionen:
- E-Mail und telefonischer Support (im ersten Jahr enthalten)
- Standard- vs. Premium-Support-Stufen
- Support-Forum für Community-Hilfe
- Erneuerung erforderlich nach erstem Jahr

Der entscheidende Unterschied ist IronPDFs Investition in Bildungseinhalte und direkten Ingeniuersupport, was die Lernkurve und die Fehlerbehebungszeit erheblich reduziert.

Was sind die besten Anwendungsfälle für jede Bibliothek?

Wann sollte man IronPDF wählen

IronPDF glänzt in Szenarien, die erfordern:

1. Integration moderner Webanwendungen

SaaS-Plattformen, die dynamische Berichte erstellen
E-Commerce-Websites erstellen Rechnungen mit Diagrammen
Business-Intelligence-Dashboards, die als PDFs exportiert werden
Anwendungen mit React, Angular oder Vue.js

2. Compliance- und Sicherheitsanforderungen

Gesundheitssysteme, die HIPAA-Konformität erfordern
Finanzdienstleistungen, die Prüfpfade erfordern
Dokumentenmanagement mit Redaction im rechtlichen Bereich
Regierungsanwendungen mit Sicherheitsrichtlinien

3. Komplexe Dokumentverarbeitung

Umwandlung mehrformatiger Dokumente (DOCX, HTML, Bilder)
OCR-Integration für gescannte Dokumente
Batch-Verarbeitung mit paralleler Ausführung
Dokumente mit digitalen Signaturen

4. Plattformübergreifende Bereitstellung

Docker-containerisierte Anwendungen
Linux-basierte Cloud-Bereitstellungen
Mikroservices-Architekturen
Serverlose Funktionen (AWS Lambda, Azure Functions)

Beispiel aus der Praxis: Erzeugung von Gesundheitsberichten

public class HealthcareReportGenerator
{
    private readonly ChromePdfRenderer _renderer;

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

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

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

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

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

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

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

        return pdf.BinaryData;
    }
}

public class HealthcareReportGenerator
{
    private readonly ChromePdfRenderer _renderer;

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

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

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

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

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

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

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

        return pdf.BinaryData;
    }
}

Public Class HealthcareReportGenerator
	Private ReadOnly _renderer As ChromePdfRenderer

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

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

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

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

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

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

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

		Return pdf.BinaryData
	End Function
End Class

$vbLabelText $csharpLabel

Wann sollte man EvoPdf wählen

EvoPdf ist gut geeignet für:

1. Einfache HTML zu PDF-Konvertierung

Grundlegende Berichte ohne komplexes JavaScript
Statische HTML-Vorlagen
Einfache Rechnungen und Belege
Massenhafte Dokumentenerstellung mit konsistenten Vorlagen

2. Kostenbewusste Teams

Unbegrenzte Entwickler auf einer einzelnen Lizenz
Niedrigere Einstiegskosten für Grundfunktionen
Projekte, die keine fortgeschrittene PDF-Manipulation erfordern

3. Spezifische Serverumgebungen

Windows-zentrierte Bereitstellungen
Anwendungen mit einfachen PDF-Anforderungen
Integration in Altsysteme

4. Hochvolumige einfache Konvertierungen

E-Mail-zu-PDF Archivierung
Statische Berichterstellung
Dokumentationssysteme
Erstellung druckbereiter Dokumente

Beispiel aus der Praxis: Rechnungserstellungssystem

public class InvoiceGenerator
{
    private readonly HtmlToPdfConverter _converter;

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

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

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

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

        // Convert to PDF
        return _converter.ConvertHtml(html, "");
    }
}

public class InvoiceGenerator
{
    private readonly HtmlToPdfConverter _converter;

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

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

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

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

        // Convert to PDF
        return _converter.ConvertHtml(html, "");
    }
}

Public Class InvoiceGenerator
	Private ReadOnly _converter As HtmlToPdfConverter

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

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

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

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

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

$vbLabelText $csharpLabel

Fortgeschrittene Implementierungsmuster und bewährte Praktiken

Optimierung der Leistung in der Produktion

Beide Bibliotheken profitieren von einer ordnungsgemäßen Konfiguration und Nutzungsmuster:

IronPDF Leistungsoptimierung

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

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

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

                // Memory optimization
                OptimizeForLowMemory = true
            }
        };

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

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

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

            return pdf.BinaryData;
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

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

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

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

                // Memory optimization
                OptimizeForLowMemory = true
            }
        };

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

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

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

            return pdf.BinaryData;
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

Public Class OptimizedPdfService
	Private ReadOnly _renderer As ChromePdfRenderer
	Private ReadOnly _semaphore As SemaphoreSlim

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

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

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

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

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

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

$vbLabelText $csharpLabel

EvoPdf-Leistungsmodelle

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

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

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

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

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

        public bool Return(HtmlToPdfConverter obj)
        {
            // Reset to default state
            obj.ConversionDelay = 2;
            return true;
        }
    }
}

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

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

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

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

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

        public bool Return(HtmlToPdfConverter obj)
        {
            // Reset to default state
            obj.ConversionDelay = 2;
            return true;
        }
    }
}

Public Class EvoPdfOptimizedService
	Private ReadOnly _converterPool As ObjectPool(Of HtmlToPdfConverter)

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

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

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

	Private Class ConverterPoolPolicy
		Implements IPooledObjectPolicy(Of HtmlToPdfConverter)

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

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

$vbLabelText $csharpLabel

Fehlerbehandlung und Fehlersuche

Robuste Fehlerbehandlung ist entscheidend für Produktionsanwendungen:

IronPDF-Fehlerbehandlung

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

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

            var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

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

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

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

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

        try
        {
            var pdf = await fallbackRenderer.RenderHtmlAsPdfAsync(html);
            return Result<byte[]>.Success(pdf.BinaryData);
        }
        catch (Exception ex)
        {
            return Result<byte[]>.Failure($"Fallback render failed: {ex.Message}");
        }
    }
}

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

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

            var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

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

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

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

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

        try
        {
            var pdf = await fallbackRenderer.RenderHtmlAsPdfAsync(html);
            return Result<byte[]>.Success(pdf.BinaryData);
        }
        catch (Exception ex)
        {
            return Result<byte[]>.Failure($"Fallback render failed: {ex.Message}");
        }
    }
}

Public Class RobustPdfGenerator
	Private ReadOnly _logger As ILogger(Of RobustPdfGenerator)
	Private ReadOnly _renderer As ChromePdfRenderer

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

			Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)

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

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

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

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

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

$vbLabelText $csharpLabel

Branchenspezifische Implementierungsbeispiele

Finanzielle Dienstleistungen: Einhaltung gesetzlicher Vorschriften

Finanzinstitute benötigen spezifische Funktionen zur Einhaltung von Vorschriften:

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

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

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

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

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

        pdf.Sign(signature);

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

        return pdf.BinaryData;
    }
}

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

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

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

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

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

        pdf.Sign(signature);

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

        return pdf.BinaryData;
    }
}

Public Class FinancialStatementGenerator
	Public Async Function GenerateQuarterlyReport(ByVal data As FinancialData) As Task(Of Byte())
		Dim renderer = New ChromePdfRenderer()

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

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

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

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

		pdf.Sign(signature)

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

		Return pdf.BinaryData
	End Function
End Class

$vbLabelText $csharpLabel

E-Commerce: Dynamische Rechnungserstellung

E-Commerce-Plattformen benötigen schnelle und zuverlässige Rechnungserstellung:

public class EcommerceInvoiceService
{
    private readonly ChromePdfRenderer _renderer;

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

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

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

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

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

        var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

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

        pdf.ApplyStamp(qrStamper);

        return pdf.BinaryData;
    }
}

public class EcommerceInvoiceService
{
    private readonly ChromePdfRenderer _renderer;

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

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

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

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

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

        var pdf = await _renderer.RenderHtmlAsPdfAsync(html);

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

        pdf.ApplyStamp(qrStamper);

        return pdf.BinaryData;
    }
}

Public Class EcommerceInvoiceService
	Private ReadOnly _renderer As ChromePdfRenderer

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

	Public Async Function GenerateInvoice(ByVal order As Order) As Task(Of Byte())
		' Build invoice HTML with order details
, order.InvoiceNumbstring.Format(r, order.Date, GenerateBarcode(order.InvoiceNumber), String.Join(TangibleTempVerbatimDoubleQuote, order.Items.Select(Function(item) $TangibleTempVerbatimCloseTag"ignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignore<tr><td>{item.Name}</td><td>{item.Quantity}</td><td>${item.Price:F2}</td><td>${item.Total:F2}</td></tr>")), TangibleStringInterpolationMarker) var html = $"TangibleTempVerbatimOpenTagTangibleTempVerbatimStringLiteralLineJoin        <html>TangibleTempVerbatimStringLiteralLineJoin        <head>TangibleTempVerbatimStringLiteralLineJoin            <style>TangibleTempVerbatimStringLiteralLineJoin                @page {{ size: A4; margin: 0; }}TangibleTempVerbatimStringLiteralLineJoin                body {{ font-family: Arial, sans-serif; }}TangibleTempVerbatimStringLiteralLineJoin                .invoice-header {{ background: #f0f0f0; padding: 20px; }}TangibleTempVerbatimStringLiteralLineJoin                .barcode {{ text-align: center; margin: 20px 0; }}TangibleTempVerbatimStringLiteralLineJoin                table {{ width: 100%; border-collapse: collapse; }}TangibleTempVerbatimStringLiteralLineJoin                th, td {{ padding: 10px; border-bottom: 1px solid #ddd; }}TangibleTempVerbatimStringLiteralLineJoin            </style>TangibleTempVerbatimStringLiteralLineJoin        </head>TangibleTempVerbatimStringLiteralLineJoin        <body>TangibleTempVerbatimStringLiteralLineJoin            <div class='invoice-header'>TangibleTempVerbatimStringLiteralLineJoin                <h1>Invoice #{0}</h1>TangibleTempVerbatimStringLiteralLineJoin                <p>Date: {1:yyyy-MM-dd}</p>TangibleTempVerbatimStringLiteralLineJoin            </div>TangibleTempVerbatimStringLiteralLineJoinTangibleTempVerbatimStringLiteralLineJoin            <div class='barcode'>TangibleTempVerbatimStringLiteralLineJoin                <img src='data:image/png;base64,{2}' />TangibleTempVerbatimStringLiteralLineJoin            </div>TangibleTempVerbatimStringLiteralLineJoinTangibleTempVerbatimStringLiteralLineJoin            <table>TangibleTempVerbatimStringLiteralLineJoin                <tr>TangibleTempVerbatimStringLiteralLineJoin                    <th>Item</th>TangibleTempVerbatimStringLiteralLineJoin                    <th>Quantity</th>TangibleTempVerbatimStringLiteralLineJoin                    <th>Price</th>TangibleTempVerbatimStringLiteralLineJoin                    <th>Total</th>TangibleTempVerbatimStringLiteralLineJoin                </tr>TangibleTempVerbatimStringLiteralLineJoin                {3}ignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignoreignore<tr><td colspan='3'><strong>Total</strong></td><td><strong>${order.Total:F2}</strong></td></tr></table><div class='footer'><p>Thank you for your business!</p><p>Return policy and terms at: www.example.com/terms</p></div></body></html>"

		Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)

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

		pdf.ApplyStamp(qrStamper)

		Return pdf.BinaryData
	End Function
End Class

$vbLabelText $csharpLabel

Migrationsstrategien: Wechsel zwischen Bibliotheken

Wenn Sie erwägen, zwischen Bibliotheken zu wechseln, finden Sie hier einen Migrationsansatz:

Migration von EvoPdf zu IronPDF

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

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

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

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

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

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

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

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

    public byte[] ConvertUrlToPdf(string url)
    {
        return _converter.ConvertUrl(url);
    }
}

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

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

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

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

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

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

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

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

    public byte[] ConvertUrlToPdf(string url)
    {
        return _converter.ConvertUrl(url);
    }
}

' EvoPdf pattern
Dim evoPdfConverter As New HtmlToPdfConverter()
evoPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4
Dim pdfBytes() As Byte = evoPdfConverter.ConvertUrl(url)

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

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

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

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

$vbLabelText $csharpLabel

Abschluss: Die richtige Wahl für Ihr Projekt treffen

Sowohl IronPDF als auch EvoPdf spielen wichtige Rollen im .NET PDF-Bibliotheksökosystem, aber sie zielen auf unterschiedliche Anwendungsfälle und Entwicklungsphilosophien ab.

Wählen Sie IronPDF, wenn Sie benötigen:

Unterstützung moderner Webstandards (CSS3, JavaScript-Frameworks)
Umfassende PDF-Manipulation über die reine Generierung hinaus
Sicherheitsfunktionen für Unternehmen und Compliance-Tools
Plattformunabhängige Bereitstellungsflexibilität
Umfangreiche Dokumentation und direkten technischen Support
Integration mit anderen Dokumentenverarbeitungstools

Wählen Sie EvoPdf, wenn Sie benötigen:

Einfache HTML-zu-PDF-Konvertierung zu geringeren Kosten
Grundlegende PDF-Erstellung für unkomplizierte Dokumente
Unbegrenzte Entwicklerlizenzen für große Teams
Schnellere Verarbeitung einfacher HTML-Inhalte
Windows-zentrierte Bereitstellungsumgebung

Die Entscheidung hängt letztendlich von Ihren spezifischen Anforderungen, Budgetbeschränkungen und langfristigen Skalierbarkeitsbedürfnissen ab. Für die meisten modernen Anwendungen, die robuste PDF-Funktionen erfordern, rechtfertigen die umfassenden Funktionen von IronPDF und die überlegene Render-Engine die Investition. EvoPdf bleibt jedoch eine brauchbare Option für einfachere Anwendungsfälle, bei denen die Kosten das Hauptanliegen sind.

Beginnen Sie mit der 30-tägigen kostenlosen Testversion von IronPDF, um seine Möglichkeiten in Ihrem spezifischen Anwendungsfall zu testen. Die Testversion umfasst alle Funktionen ohne Einschränkungen, sodass Sie eine fundierte Entscheidung basierend auf der tatsächlichen Leistung in Ihrer Umgebung treffen können.

Denken Sie daran, dass sich die tatsächlichen Kosten einer PDF-Bibliothek über den Lizenzpreis hinaus erstrecken – berücksichtigen Sie die Entwicklungszeit, den Wartungsaufwand und den potenziellen Bedarf an zusätzlichen Funktionen, während Ihre Anwendung wächst. Wählen Sie die Bibliothek, die nicht nur Ihre aktuellen Bedürfnisse erfüllt, sondern auch mit Ihren zukünftigen Anforderungen skalieren kann.

Hinweis:EvoPdf ist ein eingetragenes Warenzeichen des jeweiligen Eigentümers. Diese Website ist nicht mit EvoPdf verbunden, autorisiert 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# mit einer .NET-Bibliothek 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.

Was ist die beste .NET PDF-Bibliothek zur Verarbeitung komplexer JavaScript- und CSS-Elemente?

IronPDF ist die beste Wahl zur Verarbeitung komplexer JavaScript- und CSS-Elemente, da es eine vollständige Chrome V8 Rendering Engine verwendet, die 98%+ Browserkompatibilität mit Unterstützung für moderne Frameworks wie React und Angular bietet.

Welche .NET PDF-Bibliothek bietet eine bessere plattformübergreifende Unterstützung?

IronPDF bietet überlegene plattformübergreifende Unterstützung mit nativer Kompatibilität für Windows, Linux, macOS und Docker-Container, was eine nullkonfigurationsbasierte Bereitstellung ermöglicht.

Was sind die wichtigsten Sicherheits- und Compliance-Funktionen von IronPDF?

IronPDF bietet umfassende Sicherheitsfunktionen, einschließlich AES-256-Verschlüsselung, 15+ granularen Berechtigungseinstellungen, visuellen digitalen Signaturen und echter Inhaltsredaktion mit der RedactTextOnAllPages()-Methode.

Wie führe ich eine effiziente Stapelverarbeitung von PDFs in .NET durch?

IronPDF zeichnet sich in der Stapelverarbeitung von PDFs aus, indem es native async/await-Optimierung und besseres Speichermanagement bietet, was es geeignet für die effiziente Verarbeitung großer Dokumente macht.

Welche Bibliothek bietet bessere Unterstützung und Dokumentation für Entwickler?

IronPDF bietet umfangreichen Support und Dokumentation mit 24/5 Engineering-Support, umfassender API-Dokumentation, 100+ Code-Beispielen und Video-Tutorials, was die Entwicklungszeit erheblich reduziert.

Kann ich DOCX-Dateien mit einer .NET-Bibliothek in PDF konvertieren?

Ja, IronPDF enthält integrierte DOCX-zu-PDF-Konvertierung über seine DocxToPdfRenderer-Klasse, sodass Sie Word-Dokumente unter Beibehaltung der Formatierung konvertieren können.

Welche Vorteile hat die Verwendung von IronPDF für moderne Webanwendungen?

IronPDF eignet sich ideal für moderne Webanwendungen aufgrund seines auf Chrome basierenden Rendering-Engines, umfassender PDF-Manipulationsfunktionen und plattformübergreifender Kompatibilität, was es geeignet für dynamische Inhaltserzeugung und komplexe Dokumentenverarbeitung macht.

Wie handhabt IronPDF die PDF-Redaktion im Hinblick auf Compliance-Anforderungen?

IronPDF bietet umfassende Redaktionsfähigkeiten, einschließlich regex-basierter Inhaltsentfernung und OCR-basierter Redaktion, um die Einhaltung von Datenschutzbestimmungen wie GDPR und HIPAA zu gewährleisten.

Was macht IronPDF zu einer guten Wahl für SaaS- und E-Commerce-Plattformen?

IronPDF ist gut geeignet für SaaS- und E-Commerce-Plattformen aufgrund seiner Fähigkeit, dynamische Rechnungen zu generieren, digitale Signaturen zu unterstützen und nahtlose Integration mit modernen Webtechnologien zu bieten.

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

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

IronPDF vs EvoPdf: Welche .NET PDF-Bibliothek liefert im Jahr 2025 mehr Wert?

Wie lassen sich IronPDF und EvoPdf auf einen Blick vergleichen?

Unterstanding IronPDF and EvoPdf: Hauptstärken und Philosophie

Was zeichnet IronPDF auf dem Markt für .NET PDF-Bibliotheken aus?

Wie unterscheidet sich der Ansatz von EvoPdf bei der PDF-Erzeugung?

Wie lassen sich die plattformübergreifenden Fähigkeiten der einzelnen Bibliotheken vergleichen?

IronPDFs moderne plattformübergreifende Architektur

EvoPdfs Plattformanforderungen und -beschränkungen

Welche Bibliothek bietet die bessere PDF-Funktionalität für gängige Aufgaben?

HTML zu PDF Konvertierung: Rendering-Qualität und Leistung

IronPDF HTML zu PDF Beispiel

EvoPdf HTML zu PDF Beispiel

PDF-Sicherheit und Verschlüsselung: Schutz sensibler Dokumente

IronPDF Erweiterte Sicherheitsimplementierung

EvoPdf-Sicherheitskonfiguration

Redaktion von Inhalten: Einhaltung von Vorschriften und Schutz der Privatsphäre

IronPDF Redaction Beispiel

Formularbearbeitung: Interaktive PDFs erstellen

IronPDF Forms Beispiel

Leistungsvergleiche: Real-World Scenarios

Test der Stapelverarbeitungsleistung

Wie sehen die Preismodelle für verschiedene Teamgrößen aus?

IronPDF-Lizenzstruktur

EvoPdf-Lizenzierungsoptionen

Total Cost of Ownership-Analyse

Szenario 1: Startup mit 2 Entwicklern

Szenario 2: Wachsendes Team (5 Entwickler, mehrere Projekte)

Szenario 3: Unternehmen mit Bedarf an mehreren PDF-Tools

Szenario 4: SaaS-Produkt mit Weitervertrieb

Wie wirken sich moderne CSS-Frameworks auf Ihre Wahl aus?

IronPDF: Umfassende Framework-Unterstützung

EvoPdf: Gute CSS-Unterstützung mit Einschränkungen

Welche Dokumentations- und Supportoptionen sind für Entwickler besser geeignet?

IronPDFs Ressourcen für Entwickler

EvoPdfs Support-Struktur

Was sind die besten Anwendungsfälle für jede Bibliothek?

Wann sollte man IronPDF wählen

Wann sollte man EvoPdf wählen

Fortgeschrittene Implementierungsmuster und bewährte Praktiken

Optimierung der Leistung in der Produktion

IronPDF Leistungsoptimierung

EvoPdf-Leistungsmodelle

Fehlerbehandlung und Fehlersuche

IronPDF-Fehlerbehandlung

Branchenspezifische Implementierungsbeispiele

Finanzielle Dienstleistungen: Einhaltung gesetzlicher Vorschriften

E-Commerce: Dynamische Rechnungserstellung

Migrationsstrategien: Wechsel zwischen Bibliotheken

Migration von EvoPdf zu IronPDF

Abschluss: Die richtige Wahl für Ihr Projekt treffen

Häufig gestellte Fragen

Wie kann ich HTML in PDF in C# mit einer .NET-Bibliothek konvertieren?

Was ist die beste .NET PDF-Bibliothek zur Verarbeitung komplexer JavaScript- und CSS-Elemente?

Welche .NET PDF-Bibliothek bietet eine bessere plattformübergreifende Unterstützung?

Was sind die wichtigsten Sicherheits- und Compliance-Funktionen von IronPDF?

Wie führe ich eine effiziente Stapelverarbeitung von PDFs in .NET durch?

Welche Bibliothek bietet bessere Unterstützung und Dokumentation für Entwickler?

Kann ich DOCX-Dateien mit einer .NET-Bibliothek in PDF konvertieren?

Welche Vorteile hat die Verwendung von IronPDF für moderne Webanwendungen?

Wie handhabt IronPDF die PDF-Redaktion im Hinblick auf Compliance-Anforderungen?

Was macht IronPDF zu einer guten Wahl für SaaS- und E-Commerce-Plattformen?

Verwandte Artikel

PDF in ASP.NET MVC generieren: iTextSharp vs. IronPDF Leitfaden

Ghostscript GPL vs. IronPDF: Leitfaden für einen technischen Vergleich

ASP PDF-Bibliothek: IronPDF, Aspose und Syncfusion im Vergleich

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

Von Millionen von Ingenieur*innen weltweit vertraut

Iron Support Team