HTML zu PDF-Konverter Vergleich: Kostenlose vs kostenpflichtige Bibliotheken für .NET

Schnellstart: PDF aus HTML-String in C# erstellen

Die Umwandlung von HTML-Zeichenketten in PDF ist grundlegend für die Erstellung dynamischer Dokumente wie Rechnungen, Berichte und Zertifikate. IronPDF macht diesen Prozess bemerkenswert einfach.

Dieses Tool wandelt HTML-Zeichenketten in PDF-Dateien für dynamische Inhalte wie Rechnungen um. Was mit kostenlosen Bibliotheken Stunden dauert, ist mit der bewährten Rendering-Engine von IronPDF in Minuten erledigt.

Ausgabe

Schnellstart: Webseite mit benutzerdefinierten Einstellungen in PDF konvertieren

IronPDF bietet umfangreiche Konfigurationsmöglichkeiten für die Konvertierung von Webseiten in PDFs, darunter JavaScript Rendering, benutzerdefinierte Ränder und Medientypeinstellungen.

Dieses Tool wandelt Webseiten mit benutzerdefinierten Einstellungen in PDF-Dateien um. RenderDelay stellt sicher, dass JavaScript vollständig geladen wird – und löst so häufige Rendering-Probleme . Der Support stellt Codebeispiele und Best Practices bereit.

Ausgabe

ROI-Berechnung: Sie sparen 40 Stunden pro Entwickler und Projekt im Vergleich zu kostenlosen Alternativen. Bei 75 Dollar pro Stunde ergibt das eine Ersparnis von 3.000 Dollar – mehr als die Lizenzkosten .

Fazit: IronPDF eignet sich für Teams, die eine zuverlässige Konvertierung, dynamische Dokumente und volle Kontrolle benötigen. Die kostenlose Testversion ermöglicht eine risikofreie Bewertung.

using System.IO;
using DinkToPdf;
using DinkToPdf.Contracts;

var doc = new HtmlToPdfDocument()
{
    GlobalSettings = { PaperSize = PaperKind.A4 },
    Objects =
    {
        new ObjectSettings
        {
            HtmlContent = "<h1>Report</h1><div style='page-break-after: always;'>Page 1</div><div>Page 2</div>"
        }
    }
};

var converter = new BasicConverter(new PdfTools());
byte[] pdfBytes = converter.Convert(doc);
File.WriteAllBytes("Report.pdf", pdfBytes);

using System.IO;
using DinkToPdf;
using DinkToPdf.Contracts;

var doc = new HtmlToPdfDocument()
{
    GlobalSettings = { PaperSize = PaperKind.A4 },
    Objects =
    {
        new ObjectSettings
        {
            HtmlContent = "<h1>Report</h1><div style='page-break-after: always;'>Page 1</div><div>Page 2</div>"
        }
    }
};

var converter = new BasicConverter(new PdfTools());
byte[] pdfBytes = converter.Convert(doc);
File.WriteAllBytes("Report.pdf", pdfBytes);

Imports System.IO
Imports DinkToPdf
Imports DinkToPdf.Contracts

Dim doc As New HtmlToPdfDocument() With {
    .GlobalSettings = New GlobalSettings() With {
        .PaperSize = PaperKind.A4
    },
    .Objects = {
        New ObjectSettings() With {
            .HtmlContent = "<h1>Report</h1><div style='page-break-after: always;'>Page 1</div><div>Page 2</div>"
        }
    }
}

Dim converter As New BasicConverter(New PdfTools())
Dim pdfBytes As Byte() = converter.Convert(doc)
File.WriteAllBytes("Report.pdf", pdfBytes)

Dadurch entstehen mehrseitige Dokumente mit Umbrüchen. Ihr Team wird 2-3 Tage mit der Behebung von Problemen mit nativen Abhängigkeiten verbringen – Zeit, die besser für die Entwicklung neuer Funktionen genutzt werden sollte.

Ausgabe

using System.IO;
using DinkToPdf;
using DinkToPdf.Contracts;

var doc = new HtmlToPdfDocument()
{
    Objects = { new ObjectSettings { Page = "___PROTECTED_URL_82___" } }
};
var converter = new BasicConverter(new PdfTools());
byte[] pdfBytes = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdfBytes);

using System.IO;
using DinkToPdf;
using DinkToPdf.Contracts;

var doc = new HtmlToPdfDocument()
{
    Objects = { new ObjectSettings { Page = "___PROTECTED_URL_82___" } }
};
var converter = new BasicConverter(new PdfTools());
byte[] pdfBytes = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdfBytes);

Imports System.IO
Imports DinkToPdf
Imports DinkToPdf.Contracts

Dim doc = New HtmlToPdfDocument() With {
    .Objects = {New ObjectSettings With {.Page = "___PROTECTED_URL_82___" }}
}
Dim converter = New BasicConverter(New PdfTools())
Dim pdfBytes As Byte() = converter.Convert(doc)
File.WriteAllBytes("output.pdf", pdfBytes)

Dieses Tool wandelt Webseiten in PDF-Dateien um. Moderne JavaScript Frameworks werden fehlerhaft dargestellt. Keine Unterstützung für benutzerdefinierte Schriftarten oder responsives Design .

Ausgabe

Tatsächliche Kostenanalyse: Ihr Team wendet jährlich 20-40 Stunden für die Wartung auf. Bei 75 Dollar pro Stunde sind das 1.500 bis 3.000 Dollar – mehr als die meisten kommerziellen Lizenzen .

Urteil: DinkToPdf eignet sich für kleinere Projekte, bietet aber keine erweiterten Funktionen . Berücksichtigen Sie den langfristigen Wartungsaufwand vor der Produktionsnutzung.

Schnellstart: PDF aus dynamischem HTML generieren mit PuppeteerSharp

PuppeteerSharp bietet effektive Browser-Automatisierungsfunktionen für die PDF-Generierung, die besonders for JavaScript-lastige Inhalte nützlich sind.

Konvertiert dynamisches HTML mit JavaScript Ausführung . Ihr Team verbringt 8-12 Stunden damit, Produktionsstabilität zu erreichen, Abstürze zu bewältigen und asynchrone Komplexitäten zu managen.

Ausgabe

using PuppeteerSharp;
using PuppeteerSharp.Media;
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var chromePath = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

        if (!System.IO.File.Exists(chromePath))
        {
            Console.WriteLine("Chrome/Chromium executable not found.");
            return;
        }

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true,
            ExecutablePath = chromePath,
            Args = new[] { "--no-sandbox" }
        });

        await using var page = await browser.NewPageAsync();
        await page.GoToAsync("___PROTECTED_URL_83___");
        await page.PdfAsync("WebPage.pdf", new PdfOptions
        {
            MarginOptions = new MarginOptions { Top = "50px", Bottom = "50px" }
        });

        Console.WriteLine("PDF generated successfully!");
    }
}

using PuppeteerSharp;
using PuppeteerSharp.Media;
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var chromePath = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

        if (!System.IO.File.Exists(chromePath))
        {
            Console.WriteLine("Chrome/Chromium executable not found.");
            return;
        }

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true,
            ExecutablePath = chromePath,
            Args = new[] { "--no-sandbox" }
        });

        await using var page = await browser.NewPageAsync();
        await page.GoToAsync("___PROTECTED_URL_83___");
        await page.PdfAsync("WebPage.pdf", new PdfOptions
        {
            MarginOptions = new MarginOptions { Top = "50px", Bottom = "50px" }
        });

        Console.WriteLine("PDF generated successfully!");
    }
}

Imports PuppeteerSharp
Imports PuppeteerSharp.Media
Imports System
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim chromePath As String = "C:\Program Files\Google\Chrome\Application\chrome.exe"

        If Not System.IO.File.Exists(chromePath) Then
            Console.WriteLine("Chrome/Chromium executable not found.")
            Return
        End If

        Await Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
            .Headless = True,
            .ExecutablePath = chromePath,
            .Args = New String() {"--no-sandbox"}
        })

            Await Using page = Await browser.NewPageAsync()
                Await page.GoToAsync("___PROTECTED_URL_83___")
                Await page.PdfAsync("WebPage.pdf", New PdfOptions With {
                    .MarginOptions = New MarginOptions With {.Top = "50px", .Bottom = "50px"}
                })
            End Using
        End Using

        Console.WriteLine("PDF generated successfully!")
    End Function
End Module

Im Produktivbetrieb ist die Verwaltung von Chrome-Prozessen, die Behandlung von Abstürzen und die Implementierung von Wiederholungslogik erforderlich – was im Vergleich zu dedizierten Bibliotheken zu einer höheren Komplexität führt.

Ausgabe

Aufschlüsselung der Infrastrukturkosten:

• Zusätzlich 2-4 GB RAM pro Server
• DevOps Chrome-Verwaltung: 10-20 Stunden jährlich
• Fehlerbehebung bei Abstürzen/Speicherlecks: 15-30 Stunden pro Jahr
• Versteckte Gesamtkosten: 2.000 bis 4.000 US-Dollar jährlich

Urteil: PuppeteerSharp zeichnet sich durch pixelgenaues Rendering aus, erfordert jedoch erhebliche Investitionen in die Infrastruktur und DevOps Expertise.

Schnellstart: PDF aus HTML-String erstellen mit SelectPdf

SelectPdf bietet einen unkomplizierten Ansatz zur Konvertierung von HTML-Inhalten in PDF-Dokumente und eignet sich daher für Enterprise , die eine konsistente Ausgabe erfordern.

Konvertiert Inline- HTML für dynamische Berichte . SelectPdf verarbeitet die meisten CSS-Funktionen korrekt, allerdings sind für CSS3-Funktionen möglicherweise Workarounds erforderlich.

Ausgabe

using SelectPdf;

var converter = new SelectPdf.HtmlToPdf();
converter.Options.DisplayHeader = true;
converter.Options.DisplayFooter = true;

var doc = converter.ConvertUrl("___PROTECTED_URL_84___");
doc.Save("WebPageWithHeader.pdf");

using SelectPdf;

var converter = new SelectPdf.HtmlToPdf();
converter.Options.DisplayHeader = true;
converter.Options.DisplayFooter = true;

var doc = converter.ConvertUrl("___PROTECTED_URL_84___");
doc.Save("WebPageWithHeader.pdf");

Imports SelectPdf

Dim converter As New SelectPdf.HtmlToPdf()
converter.Options.DisplayHeader = True
converter.Options.DisplayFooter = True

Dim doc = converter.ConvertUrl("___PROTECTED_URL_84___")
doc.Save("WebPageWithHeader.pdf")

Konvertiert Webseiten mit benutzerdefinierten Kopf- und Fußzeilen für markenspezifische Dokumente. Die Kopf-/Fußzeilenoptionen decken die meisten geschäftlichen Anforderungen ab.

Ausgabe

Kosten-Nutzen-Analyse:

• Lizenz: 599–2.399 US-Dollar je nach Bereitstellung
• Zeitersparnis: 20 Stunden Entwicklung, 10 Stunden Wartung
• Support: Durchschnittliche Antwortzeit 24-48 Stunden
• Gewinnschwelle: 3-6 Monate bei über 100 PDFs täglich

Urteil: SelectPdf bietet stabile Enterprise Funktionen . Höhere Preise sind für Teams gerechtfertigt, die Zuverlässigkeit gegenüber modernen Funktionen priorisieren.## Warum EvoPdf für API-gesteuerte PDF-Workflows wählen?

EvoPdf bietet fortschrittliche HTML-zu-PDF-Konvertierungsfunktionen und eignet sich ideal für die serverseitige Verarbeitung und Szenarien mit hohem Durchsatz.

EvoPdf eignet sich hervorragend für Enterprise mit asynchroner Generierung für Web-APIs. Das Ausgabemuster byte[] lässt sich nahtlos in Microservices- Architekturen integrieren.

Schnellstart: PDF generieren mit EvoPdf

Der Byte-Array-Ansatz von EvoPdf bietet Flexibilität für API-gesteuerte Workflows und Cloud-Architekturen.

Gibt ein [byte[]](https:// IronPDF.com/how-to/export-save-pdf-csharp) zurück, um das Schreiben von Dateien oder das Streaming über eine API zu vereinfachen. Dieser Ansatz reduziert den Speicherverbrauch in Szenarien mit hohem Datenaufkommen.

Ausgabe

using EvoPdf;
using System.IO;

var htmlToPdf = new HtmlToPdfConverter();
byte[] pdfBytes = htmlToPdf.ConvertUrl("___PROTECTED_URL_85___");
File.WriteAllBytes("WebPageEvoPdf.pdf", pdfBytes);

using EvoPdf;
using System.IO;

var htmlToPdf = new HtmlToPdfConverter();
byte[] pdfBytes = htmlToPdf.ConvertUrl("___PROTECTED_URL_85___");
File.WriteAllBytes("WebPageEvoPdf.pdf", pdfBytes);

Imports EvoPdf
Imports System.IO

Dim htmlToPdf As New HtmlToPdfConverter()
Dim pdfBytes As Byte() = htmlToPdf.ConvertUrl("___PROTECTED_URL_85___")
File.WriteAllBytes("WebPageEvoPdf.pdf", pdfBytes)

Schnelle Webseitenarchivierung ohne HTML-Vorverarbeitung. Bewältigt effizient große Dokumente und komplexe Layouts.

Ausgabe

Investitionsanalyse:

• Lizenz: 650–3.250 US-Dollar pro Einsatz
• Leistung: 3- bis 5-mal schnellere Stapelverarbeitung
• Zeitersparnis für Entwickler: 30-40 Stunden API-Integration
• Infrastruktur: Reduzierte Serveranzahl durch effizienten Speicher
• Amortisationszeit: 2-4 Monate bei über 1000 PDFs/Tag

Urteil: EvoPdf eignet sich hervorragend für API-gesteuerte Workflows und die Generierung großer Datenmengen . Investitionen in API-First-Architekturen amortisieren sich schnell.