PDF-WERKZEUGE

C# HTML zu PDF Bibliotheksvergleich: Leistung, Genauigkeit und Speicher

Curtis Chau
Curtis Chau
Aktualisiert: 2. September 2026

Es gibt 7 Hauptmethoden, um HTML in PDF in C# zu konvertieren, und nicht alle Methoden liefern identische Ergebnisse. Beim Benchmarking von 7 Engines mit einer 2-seitigen Rechnung haben nur 3 diese korrekt gerendert. Von den anderen 4 haben 3 einen fälligen Betrag von 0.00 gedruckt, wo die berechnete Summe hingehörte, und die vierte hat den Summenblock komplett weggelassen, ohne einen Fehler oder eine Warnung auszugeben. Diese Engines unterscheiden sich in ihrer Unterstützung für modernes CSS, JavaScript-Ausführung, Leistung unter Last und Containergröße. Diese Unterschiede werden erst nach der Überprüfung der Ausgabe deutlich, anstatt anzunehmen, dass ein erfolgreicher Render korrekten Inhalt bedeutet. Dieser Leitfaden bietet funktionierenden Code für alle 7 Ansätze und Benchmark-Daten für jeden, alle auf einer einzigen Maschine gemessen.

Die Bibliotheken fallen in 2 Hauptkategorien, was die untenstehenden Ergebnisse weitgehend erklärt. Browser-Grade Renderer verwenden eine vollständige Chromium-Engine. IronPDF (2026.8.1) enthält Chromium innerhalb des Pakets, während PuppeteerSharp (25.8.0) und Playwright .NET (1.62.0) einen externen Browser über das DevTools-Protokoll steuern. Diese 3 replizieren die Ausgabe von Chrome, einschließlich CSS Grid, Webfonts und Canvas-basierte Diagramme, erfordern jedoch mehr Speicher und größere Container. Layout-Engine-Bibliotheken, wie iText 9 mit pdfHTML (6.3.3 auf iText Core 9.7.0), HtmlRenderer mit PdfSharp (1.6.1) und Aspose.HTML (25.7.0), verwenden ihre eigenen Layout-Engines, sind weit kleiner und oft schneller, unterstützen jedoch kein modernes JavaScript. wkhtmltopdf (0.12.6) ist ein Zwischenfall, der eine ältere Qt (4.8.5) WebKit-Engine verwendet, die ES5, aber nicht ES6 unterstützt. Alle Benchmarks in diesem Leitfaden basieren auf der Verarbeitung derselben 2-seitigen Rechnung bei 4 Parallelitätsstufen, wobei jedes PDF auf Genauigkeit überprüft wurde.

Die Kurzversion: Wo IronPDF führt

Gemessen am 3. September 2026, 5 Durchläufe, 8.960 zeitgesteuerte Renderings, auf einem inaktiven 24-Kern Windows 11 Desktop, der .NET 10 ausführt. Die vollständige Methode und Rohdaten sind unten, und das Testprogramm ist herunterladbar.

Worauf Sie sich entscheidenGewinnerGemessenWas die Alternativen kosten
Ein korrektes DokumentIronPDFSummen berechnet, Diagramm gezeichnet, Raster intakt4 der 7 lieferten ein falsches Dokument und gaben keinen Fehler aus
Durchsatz bei einem korrekten RenderIronPDF44,02 Render/s bei 8 gleichzeitig2,1x Playwright, 2,8x PuppeteerSharp auf derselben Maschine
Arbeit pro MegabyteIronPDF27,0 MB pro anhaltendem Render/s54,3 MB für Playwright, 82,9 MB für PuppeteerSharp
Kaltstart bei einem korrekten RenderIronPDF486 ms bis zum ersten PDF639 ms PuppeteerSharp, 720 ms Playwright, 1.096 ms Aspose.HTML
Was Sie betreibenIronPDFChromium wird innerhalb des NuGet-Pakets geliefertDie Browser-Engines fügen ein Image, einen Build-Zeit-Download, einen Prozesspool und eine Patch-Kadenz hinzu
Was Sie als nächstes integrierenIronPDFZusammenführen, Formulare, Signaturen, PDF/A, Verschlüsselung im selben PaketDie Browser-Engines rendern und stoppen, sodass der nächste Schritt eine zweite Abhängigkeit ist

Die oben in der Tabelle angegebenen Geschwindigkeitszahlen gehören zu Engines, die das Dokument falsch erhalten haben. iText 9 erzielte 54,30 Render pro Sekunde und HtmlRenderer 327,09, und beide taten dies, indem sie das JavaScript der Seite nie ausführten. Eine Durchsatzzahl bedeutet wenig ohne das Dokument, das es produziert hat, daher enthält jede Tabelle hier eine Genauigkeitsspalte.

IronPDF führt bei der Durchsatzrate pro korrektem Rendern: Unter den Engines, die das Dokument reproduzierten, hielt IronPDF 44,02 Renderings pro Sekunde gegenüber 20,68 und 15,60 auf derselben Maschine, demselben Dokument und derselben Wartebedingung aufrecht, während es die meiste Arbeit pro Megabyte der 3 zurückgab und das erste PDF am schnellsten erreichte.

Die Erkenntnis, die mehr zählt als jede der oben genannten: 4 der 7 Bibliotheken erzeugten ein PDF, das fertig aussah und falsch war. In 3 von ihnen lautete die Gesamtsumme der Rechnung 0.00 anstelle von 2313.30. Die vierte, HtmlRenderer, ließ stillschweigend den fälligen Betrag, die Gesamtsummen und das Diagramm weg. In keinem Fall wurde eine Ausnahme ausgelöst, und nichts im Output sagte dies aus.


HTML zu PDF Schnellstart in C#

Dieser Leitfaden stellt 7 Methoden zur Konvertierung von HTML in PDF in .NET vor und bietet Codebeispiele und quantitative Benchmarks für jede.

  • Für wen das ist: .NET-Entwickler, die HTML-zu-PDF-Bibliotheken evaluieren, und diejenigen, die ihre Auswahl mit objektiven Daten rechtfertigen müssen.
  • Was Sie erhalten: Funktionierende Beispiele für jeden Ansatz, die sowohl HTML-Strings als auch Live-URLs abdecken, zusammen mit Messungen für Kaltstart, Durchsatz, Speicherverbrauch und Rendering-Genauigkeit auf einem konsistenten Testdokument.
  • Wo es läuft: .NET 6 und höher, .NET Framework 4.6.2 und höher und .NET Standard 2.0. Benchmarks wurden auf .NET 10, Windows 11, mit 32 logischen Kernen im Release-Modus durchgeführt.
  • Wann Sie diesen Ansatz verwenden sollten: Wenn Ihr Dokument bereits im HTML-Format vorliegt. Das Rendern von kontrolliertem Markup ist effizienter und zuverlässiger als das Erstellen von PDFs durch einzelne Zeichenbefehle für dokumentähnliche Inhalte.
  • Warum es technisch wichtig ist: Engines fallen in 2 Kategorien. Browser-Grade-Renderer verwenden Chromium, was zu höheren Speicher- und Containeranforderungen führt. Layout-Engine-Bibliotheken sind kleiner und schneller, führen jedoch kein JavaScript aus. Die untenstehenden Benchmarks quantifizieren diese Kompromisse.

Um es zu verwenden, installieren Sie das Paket, geben Sie einen HTML-String an den Renderer und speichern Sie das resultierende PDF.

  1. 1Installieren Sie IronPDF mit NuGet Package Manager

    PM > Install-Package IronPdf

  2. 2Kopieren Sie diesen Codeausschnitt und führen Sie ihn aus.

    using IronPdf;
    
    License.LicenseKey = "YOUR-TRIAL-KEY";
    var pdf = new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Invoice INV-2026-0814</h1>");
    pdf.SaveAs("invoice.pdf");
  3. 3Bereitstellen zum Testen in Ihrer Live-Umgebung

    Beginnen Sie noch heute, IronPDF in Ihrem Projekt mit einer kostenlosen Testversion zu verwenden
    arrow pointer

Nach dem Kauf oder der Registrierung für eine 30-tägige IronPDF-Testversion geben Sie Ihren Lizenzschlüssel ein zu Beginn Ihrer Anwendung.

IronPdf.License.LicenseKey = "KEY";

Beginnen Sie noch heute, IronPDF in Ihrem Projekt mit einer kostenlosen Testversion zu verwenden.

Erster Schritt:
arrow pointer
NuGetMit NuGet installieren

PM > Install-Package IronPdf

Installieren Sie IronPDF, indem Sie den obigen Befehl in der NuGet Packet Manager-Konsole ausführen, oder suchen Sie das Paket im NuGet Paket Manager.
Inhaltsverzeichnis

HTML in 3 Zeilen in PDF umwandeln

Der obige Schnellstart erzeugt die folgende Ausgabe aus der Testrechnung, die in diesem Leitfaden verwendet wird.

Eine 2-seitige PDF-Rechnung, die aus HTML mit C# generiert wurde, zeigt ein CSS-Grid-Kopfteil mit einem fälligen Betrag-Abzeichen, eine 30-zeilige Positionstabelle und ein Balkendiagramm, das in JavaScript gezeichnet wurde

Das Testdokument enthält ein CSS-Grid-Kopfteil, eine 30-zeilige Tabelle mit Zebra-Streifen, ein Inline-SVG, ein Balkendiagramm, das auf einem canvas-Element gerendert wird, und in JavaScript zur Ladezeit berechnete Summen. Die berechneten Summen sind wichtig für Tests, da Engines ohne JavaScript-Unterstützung Rechnungen erzeugen, die vollständig erscheinen, aber einen fälligen Betrag von 0.00 anzeigen. Dieses Verhalten tritt bei 3 der unten aufgeführten Bibliotheken auf, und eine vierte lässt den Summenblock vollständig weg.

Häufige Fehlerszenarien werden in den folgenden Abschnitten behandelt.


1. IronPDF: Eingebettetes Chromium, kein zu installierender Browser

IronPDF ist ein Chromium-Renderer, der innerhalb Ihrer Anwendung über NuGet arbeitet und die Notwendigkeit eines separat installierten Browsers eliminiert. Diese Unterscheidung betrifft hauptsächlich die Bereitstellung, die später im Leitfaden besprochen wird.

Installation:

> dotnet add package IronPdf

Aus einem HTML-String:

// IronPDF 2026.8.1
using IronPdf;

License.LicenseKey = "YOUR-TRIAL-KEY";       // trial keys are free

string html = @"<h1>Invoice INV-2026-0814</h1>
                <p>Northwind Analytics Ltd &mdash; Net 30</p>
                <table><tr><th>Item</th><th>Amount</th></tr>
                <tr><td>Professional services</td><td>2313.30</td></tr></table>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("invoice.pdf");

Von einer Live-URL:

// IronPDF 2026.8.1 - only the render call changes.
using IronPdf;

License.LicenseKey = "YOUR-TRIAL-KEY";

var renderer = new ChromePdfRenderer();

using PdfDocument pdf = renderer.RenderUrlAsPdf("https://ironpdf.com/");
pdf.SaveAs("page.pdf");

Empfohlene Verwendung: Wählen Sie IronPDF, wenn Sie eine browsergenaue PDF-Darstellung benötigen, ohne die Infrastruktur eines Headless-Browsers zu verwalten, wie z.B. Prozesslebenszyklus, Absturzsicherung oder Containerkonfiguration.

Kompromiss: Es wird Chromium im Paket mitgeliefert, sodass der maximale Speicherverbrauch 342 MB für ein einzelnes kaltes Rendern und 1.187 MB für 8 gleichzeitige Renderings erreicht. Es beginnt auch bei 999 $, wobei 4 der anderen 6 kostenlos sind. Für ein Nebenprojekt oder ein internes Tool mit geringem Volumen ist dieser Preis schwer zu rechtfertigen.

Leistung: 486 ms Kaltstart, 161 ms mittlere Latenz bei 8 gleichzeitigen Renderings, 44,02 anhaltende Renderings pro Sekunde und 1.187 MB maximaler Speicherverbrauch im gesamten Prozessbaum. Die Testrechnung wurde genau gerendert, einschließlich des Diagramms und der Summen.


2. PuppeteerSharp: Headless Chrome für PDF-Rendering

PuppeteerSharp ist der .NET-Port von Puppeteer. Es lädt einen Chromium-Build herunter, steuert ihn über das DevTools-Protokoll und generiert PDFs. Es ist kostenlos, MIT-lizenziert, wird aktiv gepflegt und hier bei PuppeteerSharp (25.8.0) gemessen.

Installation:

> dotnet add package PuppeteerSharp

Aus einem HTML-String:

// PuppeteerSharp 25.8.0
using PuppeteerSharp;
using PuppeteerSharp.Media;

string html = @"<h1>Invoice INV-2026-0814</h1>
                <p>Northwind Analytics Ltd &mdash; Net 30</p>
                <table><tr><th>Item</th><th>Amount</th></tr>
                <tr><td>Professional services</td><td>2313.30</td></tr></table>";

// First run downloads roughly 150 MB of Chromium. Pre-fetch this at build time.
await new BrowserFetcher().DownloadAsync();

await using IBrowser browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
await using IPage page = await browser.NewPageAsync();

await page.SetContentAsync(html, new SetContentOptions
{
    WaitUntil = new[] { WaitUntilNavigation.Load }
});

await page.PdfAsync("invoice.pdf", new PdfOptions
{
    Format = PaperFormat.A4,
    PrintBackground = true
});

Von einer Live-URL:

// PuppeteerSharp 25.8.0 - GoToAsync replaces SetContentAsync.
await using IPage page = await browser.NewPageAsync();

await page.GoToAsync("https://ironpdf.com/", new NavigationOptions
{
    WaitUntil = new[] { WaitUntilNavigation.Networkidle0 }
});

await page.PdfAsync("page.pdf", new PdfOptions { Format = PaperFormat.A4, PrintBackground = true });

Empfohlene Verwendung: Wählen Sie PuppeteerSharp, wenn Budgetbeschränkungen Priorität haben und Sie sich mit der Verwaltung von Browserprozessen wohlfühlen. Es liefert identische Ausgaben wie Chrome, da es denselben Motor verwendet.

Kompromiss: Sie sind verantwortlich für die Verwaltung von Browserprozessen, einschließlich Lebenszyklus, Umgang mit verwaisten Prozessen nach Abstürzen und Konfiguration des Sandkastens. Der erste Lauf lädt etwa 150 MB Chromium herunter, was in Containern ohne ausgehenden Netzwerkzugang fehlschlagen kann, daher sollten Sie den Browser zur Build-Zeit vorab abrufen. Unter Last erzeugt PuppeteerSharp die meisten Prozesse unter den gemessenen Optionen und erreicht 40 bei 16 gleichzeitigen Renderings.

Leistung: 639 ms Kaltstart, 507 ms mittlere Latenz bei 8 gleichzeitigen Renderings, 15,60 anhaltende Renderings pro Sekunde und 1.293 MB maximaler Speicherverbrauch im gesamten Prozessbaum. Die Testrechnung wurde korrekt gerendert.


3. Playwright für .NET: Browser-Grade PDF-Rendering

Playwright für .NET ist Microsofts Bibliothek zur Browserautomatisierung. Es verwendet einen ähnlichen Ansatz wie Puppeteer, bietet jedoch eine andere API, effizientere Seitenisolierung und ähnliche Bereitstellungsüberlegungen.

Installation:

> dotnet add package Microsoft.Playwright

Ein zweiter Befehl installiert die Browser-Binärdateien.

> playwright install chromium

Das Weglassen ist die häufigste Ursache für einen fehlgeschlagenen ersten Playwright-Build in CI.

Aus einem HTML-String:

// Microsoft.Playwright 1.62.0
using Microsoft.Playwright;

string html = @"<h1>Invoice INV-2026-0814</h1>
                <p>Northwind Analytics Ltd &mdash; Net 30</p>
                <table><tr><th>Item</th><th>Amount</th></tr>
                <tr><td>Professional services</td><td>2313.30</td></tr></table>";

// Run "playwright install chromium" first, or call the installer in code.
Microsoft.Playwright.Program.Main(new[] { "install", "chromium" });

using IPlaywright playwright = await Playwright.CreateAsync();
await using IBrowser browser = await playwright.Chromium.LaunchAsync();
IPage page = await browser.NewPageAsync();

await page.SetContentAsync(html, new PageSetContentOptions { WaitUntil = WaitUntilState.Load });

await page.PdfAsync(new PagePdfOptions
{
    Path = "invoice.pdf",
    Format = "A4",
    PrintBackground = true
});

Von einer Live-URL:

// Microsoft.Playwright 1.62.0 - GotoAsync replaces SetContentAsync.
IPage page = await browser.NewPageAsync();

await page.GotoAsync("https://ironpdf.com/", new PageGotoOptions
{
    WaitUntil = WaitUntilState.NetworkIdle
});

await page.PdfAsync(new PagePdfOptions { Path = "page.pdf", Format = "A4", PrintBackground = true });

Empfohlene Verwendung: Wählen Sie Playwright für .NET, wenn Sie eine browsergenaue Darstellung ohne Kosten benötigen und seine API bevorzugen oder wenn Sie Playwright bereits für Tests verwenden und zusätzliche Abhängigkeiten vermeiden möchten.

Kompromiss: Playwright teilt dieselben Überlegungen wie Puppeteer, einschließlich Browser-Binärdateien in Ihrem Image, Prozessüberwachung und einem Installationsschritt in Ihrer Dockerfile. Es ist der stabilste hier gemessene Motor, liefert jedoch etwas mehr als die Hälfte des Durchsatzes des eingebetteten Motors.

Leistung: 720 ms Kaltstart, 381 ms mittlere Latenz bei 8 gleichzeitigen Renderings, 20,68 anhaltende Renderings pro Sekunde und 1.122 MB maximaler Speicherverbrauch im gesamten Prozessbaum. Die Testrechnung wurde korrekt gerendert.


4. iText 9 mit pdfHTML: Layout-Engine, Kein JavaScript

iText 9 mit pdfHTML ist eine PDF-Bibliothek mit einem HTML-Konvertierungs-Add-on. Es verwendet seine eigene Layout-Engine anstelle eines Browsers und bietet schnelle und vorhersehbare Ergebnisse innerhalb seiner unterstützten Funktionen, während es über alles außerhalb dieser Funktionen schweigt. Die 2 Pakete werden separat versioniert. pdfHTML (6.3.3) ist das Add-on, das auf iText Core (9.7.0) läuft, und das ist die hier gemessene Kombination.

Installation:

> dotnet add package itext.pdfhtml

Hinweis: Das Paket itext7.* ist veraltet und wurde in itext.* umbenannt, ein Detail, das in den am besten bewerteten Tutorials immer noch falsch dargestellt wird. Installieren Sie itext.pdfhtml, nicht itext7.pdfhtml. Der Paketname enthält keine Versionsnummer, daher löst itext.pdfhtml die aktuelle pdfHTML-Version auf iText 9 auf.

Aus einem HTML-String:

// itext.pdfhtml 6.3.3 - AGPL or commercial licence.
// Note the package rename: itext7.pdfhtml is deprecated in favour of itext.pdfhtml.
using iText.Html2pdf;

string html = @"<h1>Invoice INV-2026-0814</h1>
                <p>Northwind Analytics Ltd &mdash; Net 30</p>
                <table><tr><th>Item</th><th>Amount</th></tr>
                <tr><td>Professional services</td><td>2313.30</td></tr></table>";

using var output = new FileStream("invoice.pdf", FileMode.Create);
HtmlConverter.ConvertToPdf(html, output);

// No JavaScript engine and no canvas, so anything the page computes or draws
// at load time will be missing from the result.

Von einer Live-URL: iText akzeptiert keine URLs direkt. Holen Sie das HTML manuell ab und setzen Sie die Basis-URI, um sicherzustellen, dass relative Assets korrekt aufgelöst werden.

// itext.pdfhtml 6.3.3 - there is no URL method, so fetch the HTML yourself.
using iText.Html2pdf;

using var client = new HttpClient();
string html = await client.GetStringAsync("https://ironpdf.com/");

// The base URI is what lets relative images, CSS and links resolve.
var properties = new ConverterProperties();
properties.SetBaseUri("https://ironpdf.com/");

using var output = new FileStream("page.pdf", FileMode.Create);
HtmlConverter.ConvertToPdf(html, output, properties);

Empfohlene Verwendung: Wählen Sie iText, wenn Sie es bereits für andere PDF-Aufgaben verwenden oder erweiterte PDF-Manipulationen zusammen mit der HTML-Konvertierung benötigen und mehrere Bibliotheken vermeiden möchten.

Kompromiss: iText ist nur unter AGPL oder einer kostenpflichtigen Lizenz verfügbar. AGPL erfordert die Offenlegung Ihrer gesamten Anwendung, was die kostenpflichtige Option für die meisten Teams, die geschlossene Software ausliefern, notwendig macht. Technisch führt iText kein JavaScript aus und bietet im Vergleich zu Browsern eine eingeschränktere CSS-Unterstützung, wie in den unten stehenden Treue-Benchmarks gezeigt.

Leistung: 489 ms Kaltstart, 144 ms mittlere Latenz bei 8 gleichzeitigen Renderings, 54,30 anhaltende Renderings pro Sekunde und 332 MB Spitzenarbeitsspeicherverbrauch in einem einzigen Prozess. Die Gesamtsumme der Rechnung war 0.00 und das Diagramm wurde nicht gerendert.


5. HtmlRenderer mit PdfSharp: Reines Managed, Keine nativen Binärdateien

HtmlRenderer mit PdfSharp ist in reinem verwaltetem C# implementiert, ohne native Binärdateien oder Browser-Abhängigkeiten, und erfordert keine zusätzliche Container-Installation. Es ist mit großem Abstand die kleinste und schnellste hier vorgestellte Option, aber seine CSS-Unterstützung ist auf Standards von etwa 2011 beschränkt.

Installation:

> dotnet add package HtmlRenderer.PdfSharp

Aus einem HTML-String:

// HtmlRenderer.PdfSharp 1.6.1 - pure managed, no native binaries at all.
using TheArtOfDev.HtmlRenderer.PdfSharp;

string html = @"<h1>Invoice INV-2026-0814</h1>
                <p>Northwind Analytics Ltd &mdash; Net 30</p>
                <table><tr><th>Item</th><th>Amount</th></tr>
                <tr><td>Professional services</td><td>2313.30</td></tr></table>";

PdfSharp.Pdf.PdfDocument pdf = PdfGenerator.GeneratePdf(html, PdfSharp.PageSize.A4);
pdf.Save("invoice.pdf");

// There is no URL method. Fetch the markup with HttpClient and pass the string.
// CSS support stops well short of Flexbox and Grid, and there is no JavaScript.

Von einer Live-URL: Es gibt keine Methode für die direkte URL-Eingabe. Holen Sie das HTML manuell ab und übergeben Sie es als String.

Empfohlene Verwendung: Wählen Sie HtmlRenderer mit PdfSharp nur dort, wo native Binärdateien strikt verboten sind, wie in regulierten oder luftdichten Umgebungen, und nur für eine Vorlage, die zur Ladezeit nichts berechnet. Es ist eine von 3 Optionen hier, die keine nativen Binärdateien ausliefern, neben iText 9 und Aspose.HTML, und bei dieser Rechnung ließ es das Kopfteil, den Summenblock und das Diagramm weg.

Kompromiss: HtmlRenderer unterstützt kein JavaScript, Flexbox oder CSS Grid. Für feste, einfache Vorlagen kann es ausreichend sein, und seine 23 ms mittlere Latenz ist unübertroffen, in einem einzigen Prozess. HTML, das für moderne Browser entworfen wurde, wird jedoch nicht korrekt gerendert. In Tests ließ es das CSS Grid-Kopfteil, den Summenblock und das Diagramm weg und komprimierte 2 Seiten auf 1, was zu Überlappungen im Inhalt führte.

HtmlRenderer ist die schnellste gemessene Engine, kann jedoch modernes CSS nicht rendern. Beide Faktoren sollten in Ihre Entscheidung einfließen.

Leistung: 157 ms Kaltstart, 23 ms mittlere Latenz bei 8 gleichzeitigen Renderings, 327,09 anhaltende Renderings pro Sekunde, 166 MB Spitzenarbeitsspeicherverbrauch und ein einzelner Prozess. Die Ausgabe war eine einzelne Seite, die das Kopfteil, die Summen und das Diagramm fehlte.


6. wkhtmltopdf und DinkToPdf: Archiviertes Qt WebKit

wkhtmltopdf ist ein Befehlszeilenwerkzeug, das auf einer älteren Qt WebKit-Engine basiert und häufig mit .NET über DinkToPdf integriert wird. Es gibt keine NuGet-Installation für die Engine selbst, daher muss sie als Binärdatei mit Ihrer Anwendung ausgeliefert werden. DinkToPdf dient als Wrapper, obwohl es Alternativen gibt.

Aus einem HTML-String:

// wkhtmltopdf 0.12.6 via DinkToPdf. The engine is archived; the native
// libwkhtmltox binaries must be shipped alongside your application.
using DinkToPdf;
using DinkToPdf.Contracts;

string html = @"<h1>Invoice INV-2026-0814</h1>
                <p>Northwind Analytics Ltd &mdash; Net 30</p>
                <table><tr><th>Item</th><th>Amount</th></tr>
                <tr><td>Professional services</td><td>2313.30</td></tr></table>";

IConverter converter = new SynchronizedConverter(new PdfTools());

var document = new HtmlToPdfDocument
{
    GlobalSettings = { PaperSize = PaperKind.A4, Out = "invoice.pdf" },
    Objects = { new ObjectSettings { HtmlContent = html } }
};

converter.Convert(document);

Von einer Live-URL:

// wkhtmltopdf 0.12.6 via DinkToPdf - swap HtmlContent for Page.
var document = new HtmlToPdfDocument
{
    GlobalSettings = { PaperSize = PaperKind.A4, Out = "page.pdf" },
    Objects = { new ObjectSettings { Page = "https://ironpdf.com/" } }
};

converter.Convert(document);

Projektstatus: Das wkhtmltopdf-Repository wurde im Januar 2023 archiviert, mit der letzten stabilen Version (0.12.6) im Juni 2020, basierend auf Qt (4.8.5). Sein Rendering ist auf etwa 2013 Webstandards festgelegt und es erhält keine Sicherheitsupdates mehr.

Die gleiche Rechnungsseite, gerendert von einer aktuellen Chromium-Engine und von wkhtmltopdf, zeigt das Balkendiagramm und eine berechnete Summe von 2313.30 im ersten und kein Diagramm mit einer Summe von 0.00 im zweiten

Empfohlene Verwendung: Verwenden Sie wkhtmltopdf weiterhin, wenn es bereits in der Produktion ist, Ihre Dokumente korrekt rendert und Ihre Vorlagen statisch sind. Eine Migration ist ohne funktionale Anforderung nicht notwendig.

Kompromiss: wkhtmltopdf kann keine Layouts rendern, die auf Flexbox oder neueren CSS-Funktionen basieren, und es erhält keine Sicherheitspatches.

JavaScript-Unterstützung: wkhtmltopdf führt ES5 JavaScript aus, unterstützt jedoch kein ES6. Ein direkter Test auf diesem Build führte ES5 erfolgreich aus und warf bei ES6 einen Fehler, da document.querySelectorAll(...).forEach von der Qt (4.8.5) Engine nicht unterstützt wird. Infolgedessen zeigte die Testrechnung, die diesen Aufruf verwendet, einen Platzhalterwert von 0.00 ohne sichtbaren Fehler an. Vorlagen, die auf einer ES5-Basis geschrieben sind, werden korrekt berechnet, und solche, die modernes JavaScript verwenden, nicht.

Leistung: 424 ms Kaltstart, 486 ms mittlere Latenz bei 8 gleichzeitigen Rendern, 16,03 dauerhafte Render pro Sekunde und 482 MB Spitzenarbeitsspeicherverbrauch über den gesamten Prozessbaum. Die Rechnungssumme betrug 0.00 und das Diagramm wurde nicht gerendert.

Die obigen Zahlen basieren auf dem Ausführen von wkhtmltopdf.exe als Befehlszeilenwerkzeug, mit 1 Prozess pro Render. Der DinkToPdf-Wrapper verwendet die gleiche Engine im Prozess, serialisiert jedoch alle Aufrufe über SynchronizedConverter, was die Skalierbarkeit der Parallelität einschränkt.


7. Aspose.HTML für .NET: Eigenständige Layout-Engine

Aspose.HTML für .NET hat seine eigene Rendering-Engine anstelle eines Browsers und ist Teil einer Dokumentensuite, die auch Word, Excel und PowerPoint abdeckt. Für Teams, die bereits bei einem Anbieter kaufen, bedeutet das 1 Supportvertrag und 1 Bestellauftrag anstelle der Integration mehrerer Bibliotheken und der Nachverfolgung separater Verlängerungen.

Installation:

> dotnet add package Aspose.HTML

Aus einem HTML-String:

// Aspose.HTML for .NET 25.7.0 - commercial licence, applied from a .lic file.
using Aspose.Html;
using Aspose.Html.Converters;
using Aspose.Html.Saving;

new License().SetLicense("Aspose.HTMLProductFamily.lic");

string html = @"<h1>Invoice INV-2026-0814</h1>
                <p>Northwind Analytics Ltd &mdash; Net 30</p>
                <table><tr><th>Item</th><th>Amount</th></tr>
                <tr><td>Professional services</td><td>2313.30</td></tr></table>";

// The second argument is the base URL relative assets resolve against.
using var doc = new HTMLDocument(html, ".");
Converter.ConvertHTML(doc, new PdfSaveOptions(), "invoice.pdf");

// Its own rendering stack, not a browser: ES5 runs, ES6 throws, so anything the
// page computes with modern syntax is left at its initial value.

Von einer Live-URL:

// Aspose.HTML 25.7.0 - only the HTMLDocument constructor changes.
using Aspose.Html;
using Aspose.Html.Converters;
using Aspose.Html.Saving;

new License().SetLicense("Aspose.HTMLProductFamily.lic");

using var doc = new HTMLDocument("https://ironpdf.com/");
Converter.ConvertHTML(doc, new PdfSaveOptions(), "page.pdf");

Empfohlene Verwendung: Wählen Sie Aspose.HTML, wenn Sie bereits auf Aspose für andere Formate standardisiert sind und HTML-Konvertierung unter demselben Vertrag wünschen, bei Vorlagen, die nicht von modernem JavaScript abhängen.

Kompromiss: Es ist eine kostenpflichtige Bibliothek ohne kostenlose Stufe, und ihr Rendering gehört zu den Layout-Engines und nicht zu den Browsern. Aspose.HTML wurde unter einer Professional-Lizenz getestet und seine Zahlen erscheinen in jeder Tabelle unten.

Leistung: 1.096 ms Kaltstart, 227 ms mittlere Latenz bei 8 gleichzeitigen Rendern, 33,98 dauerhafte Render pro Sekunde und 334 MB Spitzenarbeitsspeicherverbrauch in einem einzelnen Prozess. Die Rechnungssumme betrug 0.00 und das Diagramm wurde nicht gerendert.


HTML zu PDF Benchmark-Methode: Versionen, Maschine und Eingaben

Jede unten stehende Zahl stammt von 1 Maschine, 1 Dokument und 1 Kampagne mit 5 Durchläufen an einem einzigen Datum. Alle 3 sind hier angegeben, damit die Zahlen reproduziert oder nach ihren Verdiensten verworfen werden können.

Gemessene Bibliotheksversionen

Die Versionsspalte zeigt, was das Testprogramm zur Laufzeit aus der geladenen Assembly ausgelesen hat, nicht gegen welche Version der Artikel geschrieben wurde. Ein Paket, das auf eine andere als die festgelegte Version aufgelöst wird, würde hier angezeigt.

BibliothekPaketGetestete VersionZur Laufzeit gemeldete AssemblyEngine
IronPDFIronPdf2026.8.12026.8.0.1Eingebettetes Chromium
Playwright .NETMicrosoft.Playwright1.62.01.62.0.0Externes Chromium
PuppeteerSharpPuppeteerSharp25.8.025.8.0.0Externes Chromium
iText 9 mit pdfHTMLitext.pdfhtml6.3.36.3.3.0 auf iText Core 9.7.0Eigene Layout-Engine
HtmlRenderer + PdfSharpHtmlRenderer.PdfSharp1.6.11.6.1.0Eigene Layout-Engine
wkhtmltopdfKommandozeilen-Binärdatei0.12.60.12.6QtWebKit 5.212 auf Qt 4.8.5
Aspose.HTMLAspose.HTML25.7.025.7.0.0Eigene Layout-Engine

Maschine, Laufzeit und Datum

ElementWert
CPU24-Kern / 32-Thread x64 Desktop, 3,2 GHz
Speicher64 GB
BetriebssystemWindows 11 x64, Build 10.0.26200
Laufzeit.NET 10.0.11, Release-Build
MaschinenzustandLeerlauf, keine anderen Anwendungen laufen
Testdatum3. September 2026
Stichprobengröße8.960 zeitgesteuerte Renderings: 7 Engines x 4 Parallelitätsstufen x 64 Renderings x 5 Durchläufe
Kaltstart-Starts105: 7 Engines x 3 Starts x 5 Durchläufe
Gemeldete ZahlMedian der 5 Durchläufe, niemals ein Bestfall

Das Testdokument und die darauf angewendeten Regeln

Jeder Engine wurde das identische HTML-Dokument mit 10.260 Zeichen im Speicher als String übergeben. Keine Engine erhielt einen Dateipfad, eine URL oder einen vorgewärmten Cache, den die anderen nicht bekamen. Das Dokument befindet sich im untenstehenden Download, sodass es verglichen werden kann, anstatt auf Vertrauen zu basieren.

  • Der Input ist eigenständig: Kein externes Stylesheet, keine Web-Schriftart, kein entferntes Bild. Nichts in der Messung hängt von der Netzwerkverzögerung oder davon ab, welche Engine Assets besser zwischenspeichert.
  • Gleiche Wartebedingung für jede Browser-Engine: Load, nicht Netzwerk-Leerlauf. PuppeteerSharp hat die Netzwerk-Leerlauf-Bedingungen für SetContent veraltet, daher ist Load die einzige Bedingung, die alle 3 identisch unterstützen.
  • Gleiche Seiteneinrichtung, mit 1 angegebenen Ausnahme: A4 und gedruckte Hintergründe auf jeder Engine. Ränder wurden nicht auf einen gemeinsamen Wert erzwungen, sodass jede Bibliothek ihren eigenen Standard verwendete, und diese Standards unterscheiden sich: IronPDF setzt die Seite ein, wo die 2 externen Browser-Engines dies nicht tun. Das ist im Vergleich weiter unten sichtbar. Es ändert, wie viel Weißraum den Inhalt umgibt, nicht das, was die Engines berechnet haben. Die 6 Engines, die den Seitenumbruch beachteten, produzierten 2 Seiten. HtmlRenderer produzierte 1, da der Umbruch verloren ging und nicht aufgrund der Ränder.
  • Die Engines, die eine bezahlte Lizenz benötigten, hatten eine: IronPDF unter einer Voll-Lizenz und Aspose.HTML unter Professional, sodass keine durch Testlimits gedrosselt oder mit Wasserzeichen versehen wurde. iText lief unter AGPL, was keine funktionalen Einschränkungen auferlegt.
  • Jede Engine erhielt die Konfiguration, die ihre eigene Dokumentation empfiehlt: 1 Renderer- oder Browser-Instanz, die über Render hinweg wiederverwendet wird, eine neue Seite pro Render für Puppeteer und Playwright, und Aspose.HTML schreibt in eine MemoryStream, sodass keine Festplattenkosten anfallen, die die anderen vermeiden.

Zeitgrenze: Die Stoppuhr startet, wenn der Renderaufruf gemacht wird, und stoppt, wenn die Engine PDF-Bytes zurückgibt. Sie schließt den Aufbau der Engine und den Start des Browsers aus, die separat als Kaltstart gemessen werden, und sie schließt das Schreiben auf die Festplatte aus, was keine der Engines tun sollte. Der Durchsatz ist erfolgreiche Render geteilt durch die Echtzeitsekunden für das gesamte Batch, nicht die Summe der einzelnen Renderzeiten, da nur das erste beschreibt, was ein Dienst unter Last liefert.

Speicherdefinition: Spitzen-Arbeitssatz summiert über den gesamten Prozessbaum, alle 100 ms abgetastet, wobei der Baum jeder Prozess ist, der vom Benchmark-Prozess durch echte Eltern- und Kind-Abstammung abstammt. Es ist ein Spitzenwert und kein Durchschnitt, da der Spitzenwert entscheidet, ob ein Container seine geschäftigste Sekunde überlebt. Eine Browser-Engine hält den Großteil ihres Speichers in erzeugten Kindprozessen, daher würde das Messen nur des .NET-Prozesses die Engine bevorzugen, die die meisten Prozesse erzeugt.

Was als Fehler zählt: Jeder Render, der weniger als 500 Bytes zurückgibt. Fehler werden aus dem Durchsatz-Zähler entfernt und separat gemeldet, sodass eine Engine keine hohe Rate erzielen kann, indem sie nichts zurückgibt. Über die 35 Aufrufe hinter diesen Tabellen hinweg hat keine Engine auf irgendeiner Ebene einen einzigen Fehler aufgezeichnet.


Zusammenfassung des HTML-zu-PDF-Benchmarks

Alle Geschwindigkeits- und Speicherwerte in den folgenden Tabellen basieren auf tatsächlichen Messungen. Wo eine Bibliothek nicht gemessen wurde, wird dies in der Tabelle explizit angegeben.

BibliothekKaltstartWarm p50 bei 8Durchsatz bei 8Spitzenspeicher bei 8Rendert die TestrechnungLizenz
IronPDF (2026.8.1)486 ms161 ms44.02/s1,187 MBKorrektAb $999
Playwright .NET (1.62.0)720 ms381 ms20.68/s1,122 MBKorrektMIT
PuppeteerSharp (25.8.0)639 ms507 ms15.60/s1,293 MBKorrektMIT
iText 9 pdfHTML (6.3.3)489 ms144 ms54.30/s332 MBGesamt 0.00, kein DiagrammAGPL oder bezahlt
HtmlRenderer + PdfSharp (1.6.1)157 ms23 ms327.09/s166 MBKein Kopf, keine Summen, kein DiagrammKostenlos, BSD
wkhtmltopdf (0.12.6)424 ms486 ms16.03/s482 MBGesamt 0.00, kein DiagrammLGPL, archiviert
Aspose.HTML (25.7.0)1,096 ms227 ms33.98/s334 MBGesamt 0.00, kein DiagrammBezahlt

Getestet auf: 24-Kern / 32-Thread x64 Desktop-CPU · 3,2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · zuletzt überprüft September 2026

Interpretieren Sie die Durchsatzwerte im Zusammenhang mit der Rendering-Genauigkeit. Von den 7 gemessenen Engines haben 4 wesentliche Rendering-Arbeiten ausgelassen, und die 2 schnellsten Ergebnisse in der Tabelle, iText 9 mit 54.30/s und HtmlRenderer mit 327.09/s, stammen beide aus dieser Gruppe.


Vollständige HTML-zu-PDF-Benchmark-Ergebnisse nach Engine

Die folgenden Abschnitte bieten detaillierte Zahlen für jeden Eintrag in der Zusammenfassungstabelle.

Wie wurde dieser Benchmark gemessen?

Das Testdokument

Jede Engine hat die gleiche 2-seitige Rechnung gerendert, wie oben beschrieben. Was es zu einem Messinstrument anstelle eines Beispiels macht, sind die Summen. Sie werden im Markup als Platzhalter 0.00 Werte geliefert und beim Laden in JavaScript berechnet, sodass eine Engine, die das Skript ausgeführt hat, 2313.30 in die Textebene schreibt und eine Engine, die dies nicht getan hat, den Platzhalter dort belässt, wo ein regulärer Ausdruck ihn findet.

using System.Text;

// The benchmark document. Two pages, a CSS Grid masthead, a 30-row table,
// an inline SVG mark, and a bar chart drawn on a canvas element.
//
// The totals ship as placeholder zeroes and are computed in JavaScript at load
// time, so the output itself records whether the engine ran the script. An
// engine with no script engine produces a clean invoice whose total reads 0.00.
static class TestDocument
{
    public static string Invoice()
    {
        var rows = new StringBuilder();
        for (int i = 1; i <= 30; i++)
        {
            decimal unit = 12.50m + (i % 7) * 3.25m;
            int qty = 1 + (i % 5);
            rows.Append($@"
      <tr>
        <td>{i:00}</td>
        <td>Professional services, line item {i:00}</td>
        <td class=""num"">{qty}</td>
        <td class=""num"">{unit:0.00}</td>
        <td class=""num"">{unit * qty:0.00}</td>
      </tr>");
        }

        return $@"<!DOCTYPE html>
<html lang=""en"">
<head>
<meta charset=""utf-8"">
<title>Invoice INV-2026-0814</title>
<style>
  body {{ font-family: 'Segoe UI', 'Helvetica Neue', Arial, sans-serif; color:#1c2430; padding:32px; font-size:12px; }}
  .masthead {{ display:grid; grid-template-columns: 1fr 1fr 220px; gap:20px;
               border-bottom:3px solid #0b5cab; padding-bottom:16px; margin-bottom:22px; }}
  .badge {{ background:#0b5cab; color:#fff; padding:10px 14px; border-radius:6px; text-align:center; }}
  table {{ width:100%; border-collapse:collapse; }}
  th {{ background:#eef3f9; text-align:left; padding:7px 9px; border-bottom:2px solid #c6d4e5; }}
  td {{ padding:6px 9px; border-bottom:1px solid #e7ecf3; }}
  tr:nth-child(even) td {{ background:#fafbfd; }}
  td.num, th.num {{ text-align:right; font-variant-numeric:tabular-nums; }}
  .chartwrap {{ margin-top:26px; display:grid; grid-template-columns:1fr 240px; gap:24px; }}
  .totals {{ list-style:none; padding:0; }}
  .totals li {{ display:flex; justify-content:space-between; padding:5px 0; border-bottom:1px solid #e7ecf3; }}
  .totals li.grand {{ font-weight:700; font-size:15px; border-top:2px solid #0b5cab; }}
</style>
</head>
<body>

<header class=""masthead"">
  <div>
    <svg width=""34"" height=""34"" viewBox=""0 0 34 34"">
      <rect width=""34"" height=""34"" rx=""7"" fill=""#0b5cab""/>
      <circle cx=""24"" cy=""17"" r=""3.2"" fill=""#7fb2e8""/>
    </svg>
    <h1>Invoice</h1>
  </div>
  <dl><dt>Number</dt><dd>INV-2026-0814</dd><dt>Terms</dt><dd>Net 30</dd></dl>
  <div class=""badge"">Amount due<span id=""badge-total"">0.00</span>GBP</div>
</header>

<table>
  <thead>
    <tr><th>#</th><th>Description</th><th class=""num"">Qty</th><th class=""num"">Unit</th><th class=""num"">Amount</th></tr>
  </thead>
  <tbody>{rows}
  </tbody>
</table>

<section class=""chartwrap"">
  <div>
    <strong>Spend by quarter</strong>
    <canvas id=""chart"" width=""420"" height=""140""></canvas>
  </div>
  <ul class=""totals"">
    <li><span>Subtotal</span><span id=""sub"">0.00</span></li>
    <li><span>VAT 20%</span><span id=""vat"">0.00</span></li>
    <li class=""grand""><span>Total</span><span id=""tot"">0.00</span></li>
  </ul>
</section>

<script>
  // Totals are computed here, not in the markup. An engine that skips
  // JavaScript leaves the placeholder zeroes in the output.
  var sub = 0;
  document.querySelectorAll('tbody tr').forEach(function (tr) {{
    sub += parseFloat(tr.lastElementChild.textContent);
  }});
  var vat = sub * 0.2, tot = sub + vat;
  var f = function (n) {{ return n.toFixed(2); }};
  document.getElementById('sub').textContent = f(sub);
  document.getElementById('vat').textContent = f(vat);
  document.getElementById('tot').textContent = f(tot);
  document.getElementById('badge-total').textContent = f(tot);

  // A canvas chart, the way a dashboard library would draw one.
  var data = [sub * 0.18, sub * 0.31, sub * 0.22, sub * 0.29];
  var c = document.getElementById('chart').getContext('2d');
  var max = Math.max.apply(null, data), bw = 78, gap = 26, base = 128;
  data.forEach(function (v, i) {{
    var h = Math.round((v / max) * 104);
    c.fillStyle = i % 2 ? '#7fb2e8' : '#0b5cab';
    c.fillRect(18 + i * (bw + gap), base - h, bw, h);
    c.fillStyle = '#1c2430';
    c.font = '10px sans-serif';
    c.fillText('Q' + (i + 1), 18 + i * (bw + gap) + 30, base + 11);
  }});
</script>

</body>
</html>";
    }
}

Was jede Zahl bedeutet

  • Durchsatz: erfolgreiche Renderings geteilt durch die Echtzeitsekunden für das gesamte Batch, nicht die Summe der einzelnen Renderzeiten. Nur der erste beschreibt, was ein Dienst unter gleichzeitiger Ausführung liefert.
  • Fehler: jedes Rendering, das weniger als 500 Bytes zurückgibt. Fehler werden aus dem Durchsatz-Zähler entfernt und separat gemeldet, sodass eine Engine keine hohe Rate erzielen kann, indem sie nichts zurückgibt. Bei den 35 Aufrufen hinter dieser Tabelle hat keine Engine auf irgendeiner Ebene einen einzigen Fehler verzeichnet.
  • p50 und p95: entnommen aus der sortierten Liste der Latenzen pro Rendering durch lineare Interpolation, nicht aus einem Mittelwert. Ein Mittelwert verbirgt das Ende, und das Ende ist das, worauf ein Benutzer wartet.
  • Spitzenspeicher: der Höchststand von WorkingSet64 summiert über den Prozessbaum, alle 100 ms abgetastet. Es ist ein Spitzenwert und kein Durchschnitt, weil der Spitzenwert entscheidet, ob ein Container seine geschäftigste Sekunde überlebt.
  • Kaltstart: die Zeit von einem neuen Prozess bis zum ersten PDF, als das beste von 3 Starts genommen, nicht als Median. Der erste Start einer beliebigen Engine absorbiert einmalige Kosten wie das Laden von Assemblies, einen Browser-Download oder eine native Extraktion. Diese sind reale Bereitstellungskosten, aber keine Kosten pro Start, und sie in den Durchschnitt einzubeziehen, verwischt zwei verschiedene Zahlen.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

const int TotalRenders = 64;
int[] levels = { 1, 4, 8, 16 };

string html = TestDocument.Invoice();
IEngine engine = Engines.Create("ironpdf");
await engine.InitAsync();

// Warm the engine so the sweep measures steady state rather than a cold start
// smeared across the first few results.
for (int i = 0; i < 5; i++) await engine.RenderAsync(html);

foreach (int concurrency in levels)
{
    var sampler = new TreeMemorySampler();
    var latencies = new List<double>(TotalRenders);
    int failures = 0;
    object gate = new();

    GC.Collect();
    GC.WaitForPendingFinalizers();

    sampler.Start();
    var wall = Stopwatch.StartNew();

    using (var semaphore = new SemaphoreSlim(concurrency))
    {
        IEnumerable<Task> work = Enumerable.Range(0, TotalRenders).Select(async _ =>
        {
            await semaphore.WaitAsync();
            var perRender = Stopwatch.StartNew();
            try
            {
                byte[] pdf = await engine.RenderAsync(html);
                perRender.Stop();

                // An engine that returns quickly by returning nothing must not
                // be rewarded with a throughput number.
                if (pdf == null || pdf.Length < 500) lock (gate) failures++;
                else lock (gate) latencies.Add(perRender.Elapsed.TotalMilliseconds);
            }
            catch
            {
                lock (gate) failures++;
            }
            finally { semaphore.Release(); }
        });

        await Task.WhenAll(work);
    }

    wall.Stop();
    sampler.Stop();
    latencies.Sort();

    double throughput = (TotalRenders - failures) / wall.Elapsed.TotalSeconds;

    Console.WriteLine(
        $"C={concurrency,-2} {throughput,6:0.00} rend/s  " +
        $"p50 {Percentile(latencies, 50),6:0} ms  " +
        $"p95 {Percentile(latencies, 95),6:0} ms  " +
        $"peak {sampler.PeakBytes / 1024.0 / 1024.0,6:0} MB  " +
        $"procs {sampler.PeakProcessCount,2}  fail {failures}");
}

await engine.DisposeAsync();

// Report percentiles rather than means. A mean hides the tail, and the tail is
// what your users experience.
static double Percentile(List<double> sorted, int p)
{
    if (sorted.Count == 0) return -1;

    double rank = (p / 100.0) * (sorted.Count - 1);
    int low = (int)Math.Floor(rank);
    int high = (int)Math.Ceiling(rank);

    return low == high
        ? sorted[low]
        : sorted[low] + (rank - low) * (sorted[high] - sorted[low]);
}
using System;
using System.Diagnostics;
using System.Globalization;
using System.Threading.Tasks;

// Cold start cannot be measured inside a process that has already rendered.
// The parent spawns this same binary with --cold, so every reading is a real
// process start rather than a first call inside an already-warm runtime.

// --- child mode: initialise one engine, render once, print, exit ------------
if (args.Length == 2 && args[0] == "--cold")
{
    var sampler = new TreeMemorySampler();
    sampler.Start();

    var sw = Stopwatch.StartNew();
    IEngine engine = Engines.Create(args[1]);
    await engine.InitAsync();
    byte[] first = await engine.RenderAsync(TestDocument.Invoice());
    sw.Stop();

    sampler.Stop();

    Console.WriteLine($"COLD_MS={sw.Elapsed.TotalMilliseconds:0.0}");
    Console.WriteLine($"COLD_PEAK_MB={sampler.PeakBytes / 1024.0 / 1024.0:0.0}");
    Console.WriteLine($"BYTES={first.Length}");

    try { await engine.DisposeAsync(); } catch { }
    Environment.Exit(0);
}

// --- parent mode: run three fresh children and take the minimum -------------
static (double ms, double peakMb) RunColdChild(string engineId)
{
    var psi = new ProcessStartInfo
    {
        FileName = Environment.ProcessPath,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        UseShellExecute = false
    };
    psi.ArgumentList.Add("--cold");
    psi.ArgumentList.Add(engineId);

    using Process p = Process.Start(psi);
    string output = p.StandardOutput.ReadToEnd();
    p.WaitForExit(180_000);

    double ms = -1, mb = 0;
    foreach (string line in output.Split('\n'))
    {
        if (line.StartsWith("COLD_MS="))
            double.TryParse(line.Substring(8).Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out ms);
        if (line.StartsWith("COLD_PEAK_MB="))
            double.TryParse(line.Substring(13).Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out mb);
    }
    return (ms, mb);
}

// Take the minimum of three, not the mean. The first run of any engine absorbs
// one-time costs - assembly loading, a browser download, a native extraction -
// which are real deployment costs but are not per-start costs, and averaging
// them in blurs two different numbers together.
var readings = new List<double>();
double peak = 0;

for (int i = 0; i < 3; i++)
{
    var (ms, mb) = RunColdChild("ironpdf");
    if (ms > 0) { readings.Add(ms); peak = Math.Max(peak, mb); }
}

Console.WriteLine($"cold start (best of {readings.Count}): {readings.Min():0} ms, peak {peak:0} MB");

Die Steuerungen

Das Testprogramm wendet diese Steuerungen auf jede Messung an.

  • Jede Engine rendert 5 Dokumente, bevor irgendeine Zeitmessung beginnt, sodass die Zahlen den stabilen Zustand beschreiben und nicht ein Aufwärmen, das über die ersten Ergebnisse verteilt ist.
  • GC.Collect und WaitForPendingFinalizers laufen vor jedem Level.
  • Eine 6-sekündige Beruhigung folgt jeder Engine innerhalb des Testprogramms, und der Runner lässt weitere 8 Sekunden zwischen den Engine-Prozessen, sodass die Kinder einer Engine beendet sind, bevor die nächste startet.
  • Jede Engine wird in ihrem eigenen Prozess gemessen. Eine browserbasierte Engine hält den Großteil ihres Speichers in gestarteten Kindern, die ein einzelnes Rendering überdauern, sodass das Messen von 2 Engines in 1 Prozess den residenten Browser der ersten Engine der zweiten anlastet.
  • Ein Durchlauf wird nur aufgezeichnet, wenn die Engine alle 4 Parallelitätsebenen abgeschlossen hat und die Ergebnisdatei den Namen der angeforderten Engine enthält. Ein Aufruf, der mitten im Durchlauf stirbt, schreibt nichts, und ohne diese Überprüfung wird die Datei der vorherigen Engine archiviert, was die Zahlen einer Engine unter dem Namen einer anderen Engine ablegt. Das geschah einmal während dieser Kampagne, bei einem IronPDF-Durchlauf, der während seines 16-Render-Levels starb, und der Durchlauf wurde erneut durchgeführt, anstatt veröffentlicht zu werden.
  • Speicher wird durch echte Eltern- und Kind-Abstammung zugeordnet, nicht durch Prozessnamen. Ein Prozess zählt, wenn er vom Benchmark-Prozess abstammt, transitiv durchlaufen und gemerkt, sodass ein Enkelkind immer noch zählt, nachdem das Kind, das es gestartet hat, beendet ist. Erstellungszeiten schützen jeden Anspruch, weil Windows Prozess-IDs schneller recycelt, als diese Engines Renderer-Prozesse durchlaufen.
  • Der Baum und sein Speicher stammen aus 1 systemweiten Snapshot pro Probe, anstatt einer separaten Abfrage pro Prozess. Das Betriebssystem nacheinander nach jedem Prozess zu fragen, kann mit einer Engine, die Renderer schneller startet und beendet als das Probeintervall, nicht mithalten. Gemessen an einer unabhängigen Messung, die über WMI durchgeführt wurde, meldete diese Methode einen 26-Prozess-Chromium-Baum als 11.

Die Konfiguration pro Engine wird in den Adaptern festgelegt. Jede der folgenden Entscheidungen vermeidet es, einer Engine einen Konfigurationsvorteil zu geben.

  • Jede Browser-Engine erhält die gleiche Wartebedingung, Load, die gleiche A4-Papiergröße und gedruckte Hintergründe.
  • PuppeteerSharp und Playwright erhalten pro Rendering eine neue Seite, das Muster, das ihre eigene Dokumentation empfiehlt, und die günstigere der beiden Optionen.
  • Aspose.HTML schreibt in einen MemoryStream über den eigenen Stream-Provider der Bibliothek, sodass es keine Festplatten-I/O zahlt, die die anderen vermeiden.
  • wkhtmltopdf läuft als das Kommandozeilen-Tool, das es ist, 1 Prozess pro Rendering über stdin und stdout.
  • Die 2 Engines, die für diese Nutzung eine kostenpflichtige Lizenz benötigen, liefen unter einer, Aspose.HTML unter Professional und IronPDF unter einer Vollversion, sodass keine durch Testbeschränkungen gedrosselt oder mit Wasserzeichen versehen wurde. iText lief unter seinen AGPL-Bedingungen, die Lizenzverpflichtungen, aber keine funktionalen Beschränkungen mit sich bringen.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;

// Samples the whole process tree, not just the .NET process.
//
// Several rendering libraries keep most of their memory in spawned browser
// processes, so measuring only the managed side flatters whichever engine
// spawns the most children. Two things have to be right for the reading to be
// fair, and both are easy to get wrong.
//
// First, attribution is by real ancestry rather than by process name. Matching
// a list of renderer names and counting anything that started after the
// benchmark did over-counts on any machine with a browser or an Electron
// application open: a library that spawns nothing reports several processes and
// a few hundred spare MB.
//
// Second, the tree and its memory are read from one system-wide snapshot.
// Asking the operating system about each process in turn cannot keep up with an
// engine that starts and exits renderers faster than the sample interval: the
// child is in the process list, and gone by the time its working set is read.
// NtQuerySystemInformation returns process id, parent id, creation time and
// working set for every process in a single call, so the shape of the tree and
// the memory in it come from the same instant.
sealed class TreeMemorySampler
{
    // pid -> the creation time it had when it was claimed. Windows recycles
    // process ids quickly and these engines churn through short-lived children,
    // so a pid on its own is not an identity.
    readonly Dictionary<int, long> _ours = new Dictionary<int, long>();
    long _ourCreateTime = -1;

    CancellationTokenSource _cts;
    Task _loop;

    public long PeakBytes { get; private set; }
    public int PeakProcessCount { get; private set; }

    public void Start()
    {
        PeakBytes = 0;
        PeakProcessCount = 0;
        _cts = new CancellationTokenSource();
        CancellationToken token = _cts.Token;

        _loop = Task.Run(async () =>
        {
            while (!token.IsCancellationRequested)
            {
                Sample();
                try { await Task.Delay(100, token); }
                catch (TaskCanceledException) { return; }
            }
        }, token);
    }

    public void Stop()
    {
        Sample();                 // one final reading, in case the peak landed late
        _cts?.Cancel();
        try { _loop?.Wait(2000); } catch { }
    }

    void Sample()
    {
        List<Entry> all = Snapshot();
        if (all.Count == 0) return;

        int self = Environment.ProcessId;
        foreach (Entry e in all)
            if (e.Pid == self) { _ourCreateTime = e.CreateTime; break; }
        if (_ourCreateTime < 0) return;
        _ours[self] = _ourCreateTime;

        // Drop any claim whose pid now carries a different creation time: that
        // pid was recycled and the process wearing it belongs to someone else.
        var live = new Dictionary<int, long>(all.Count);
        foreach (Entry e in all) live[e.Pid] = e.CreateTime;

        var recycled = new List<int>();
        foreach (KeyValuePair<int, long> claim in _ours)
        {
            long now;
            if (live.TryGetValue(claim.Key, out now) && now != claim.Value)
                recycled.Add(claim.Key);
        }
        foreach (int pid in recycled) _ours.Remove(pid);

        // Grow the owned set until it stops growing: a child seen in this
        // snapshot may itself be the parent of another process in it. Claims
        // survive the process exiting, so a grandchild still counts once the
        // child that launched it is gone.
        bool added = true;
        while (added)
        {
            added = false;
            foreach (Entry e in all)
            {
                if (_ours.ContainsKey(e.Pid)) continue;

                long parentClaim;
                if (!_ours.TryGetValue(e.Ppid, out parentClaim)) continue;

                // A parent only vouches for children started after it.
                if (e.CreateTime < parentClaim) continue;

                _ours[e.Pid] = e.CreateTime;
                added = true;
            }
        }

        long total = 0;
        int count = 0;
        foreach (Entry e in all)
        {
            long claim;
            if (!_ours.TryGetValue(e.Pid, out claim) || claim != e.CreateTime) continue;
            total += e.WorkingSet;
            count++;
        }

        // Track the peak, not the average. The peak is what decides whether
        // the container survives its busiest second.
        if (total > PeakBytes) PeakBytes = total;
        if (count > PeakProcessCount) PeakProcessCount = count;
    }

    readonly struct Entry
    {
        public readonly int Pid, Ppid;
        public readonly long CreateTime, WorkingSet;

        public Entry(int pid, int ppid, long create, long ws)
        {
            Pid = pid; Ppid = ppid; CreateTime = create; WorkingSet = ws;
        }
    }

    // ---- one atomic system-wide process snapshot ---------------------------
    // SYSTEM_PROCESS_INFORMATION, x64 field offsets: CreateTime 32,
    // UniqueProcessId 80, InheritedFromUniqueProcessId 88, WorkingSetSize 144.

    const int SystemProcessInformation = 5;
    const uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;

    [DllImport("ntdll.dll")]
    static extern uint NtQuerySystemInformation(int systemInformationClass,
        IntPtr systemInformation, int systemInformationLength, out int returnLength);

    static int _bufferSize = 1 << 20;

    static List<Entry> Snapshot()
    {
        var list = new List<Entry>(400);
        IntPtr buffer = IntPtr.Zero;
        try
        {
            for (int attempt = 0; attempt < 8; attempt++)
            {
                if (buffer != IntPtr.Zero) Marshal.FreeHGlobal(buffer);
                buffer = Marshal.AllocHGlobal(_bufferSize);

                int needed;
                uint status = NtQuerySystemInformation(
                    SystemProcessInformation, buffer, _bufferSize, out needed);

                if (status == 0)
                {
                    long offset = 0;
                    while (true)
                    {
                        IntPtr entry = buffer + (int)offset;
                        int next = Marshal.ReadInt32(entry, 0);
                        long create = Marshal.ReadInt64(entry, 32);
                        int pid = (int)Marshal.ReadIntPtr(entry, 80);
                        int ppid = (int)Marshal.ReadIntPtr(entry, 88);
                        long ws = (long)Marshal.ReadIntPtr(entry, 144);

                        if (pid != 0) list.Add(new Entry(pid, ppid, create, ws));
                        if (next == 0) break;
                        offset += next;
                    }
                    return list;
                }

                if (status != STATUS_INFO_LENGTH_MISMATCH) return list;
                _bufferSize = Math.Max(needed + (64 * 1024), _bufferSize * 2);
            }
        }
        catch { }
        finally { if (buffer != IntPtr.Zero) Marshal.FreeHGlobal(buffer); }

        return list;
    }
}
using System;
using System.IO;
using System.Threading.Tasks;
using IronPdf;
using PuppeteerSharp.Media;
using PW = Microsoft.Playwright;
using PS = PuppeteerSharp;
using iText.Html2pdf;

// One interface so a single sweep loop drives every engine. Anyone reading your
// results will check these adapters, so the fairness decisions belong here and
// should be stated alongside the numbers.
interface IEngine
{
    string Version { get; }
    Task InitAsync();
    Task<byte[]> RenderAsync(string html);
    Task DisposeAsync();
}

static class Engines
{
    public static readonly string[] All =
        { "ironpdf", "puppeteersharp", "playwright", "itext-pdfhtml" };

    public static IEngine Create(string id) => id switch
    {
        "ironpdf" => new IronPdfEngine(),
        "puppeteersharp" => new PuppeteerEngine(),
        "playwright" => new PlaywrightEngine(),
        "itext-pdfhtml" => new ITextEngine(),
        _ => throw new ArgumentException("unknown engine: " + id)
    };
}

// One renderer instance, reused across every render. ChromePdfRenderer is
// thread-safe and stateless per render, so this is both the documented pattern
// and what a real service would do.
sealed class IronPdfEngine : IEngine
{
    ChromePdfRenderer _renderer;

    public string Version => typeof(ChromePdfRenderer).Assembly.GetName().Version?.ToString();

    public Task InitAsync()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        _renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
        return Task.CompletedTask;
    }

    public async Task<byte[]> RenderAsync(string html)
    {
        using PdfDocument pdf = await _renderer.RenderHtmlAsPdfAsync(html);
        return pdf.BinaryData;
    }

    public Task DisposeAsync() => Task.CompletedTask;
}

// One browser, a fresh page per render. Page-per-render is what the Puppeteer
// documentation recommends and it is the cheaper of the two options, so it is
// the favourable choice here rather than the convenient one.
sealed class PuppeteerEngine : IEngine
{
    PS.IBrowser _browser;

    public string Version => typeof(PS.Puppeteer).Assembly.GetName().Version?.ToString();

    public async Task InitAsync()
    {
        await new PS.BrowserFetcher().DownloadAsync();
        _browser = await PS.Puppeteer.LaunchAsync(new PS.LaunchOptions { Headless = true });
    }

    public async Task<byte[]> RenderAsync(string html)
    {
        await using PS.IPage page = await _browser.NewPageAsync();

        // Load, not networkidle. PuppeteerSharp deprecated the networkidle
        // conditions for SetContent, and every engine here is given the same
        // wait condition so the comparison stays like for like.
        await page.SetContentAsync(html, new PS.SetContentOptions
        {
            WaitUntil = new[] { PS.WaitUntilNavigation.Load }
        });

        return await page.PdfDataAsync(new PS.PdfOptions
        {
            Format = PaperFormat.A4,
            PrintBackground = true
        });
    }

    public async Task DisposeAsync()
    {
        if (_browser != null) await _browser.CloseAsync();
    }
}

sealed class PlaywrightEngine : IEngine
{
    PW.IPlaywright _playwright;
    PW.IBrowser _browser;

    public string Version => typeof(PW.Playwright).Assembly.GetName().Version?.ToString();

    public async Task InitAsync()
    {
        Microsoft.Playwright.Program.Main(new[] { "install", "chromium" });
        _playwright = await PW.Playwright.CreateAsync();
        _browser = await _playwright.Chromium.LaunchAsync(
            new PW.BrowserTypeLaunchOptions { Headless = true });
    }

    public async Task<byte[]> RenderAsync(string html)
    {
        PW.IPage page = await _browser.NewPageAsync();
        try
        {
            await page.SetContentAsync(html, new PW.PageSetContentOptions
            {
                WaitUntil = PW.WaitUntilState.Load
            });

            return await page.PdfAsync(new PW.PagePdfOptions
            {
                Format = "A4",
                PrintBackground = true
            });
        }
        finally { await page.CloseAsync(); }
    }

    public async Task DisposeAsync()
    {
        if (_browser != null) await _browser.CloseAsync();
        _playwright?.Dispose();
    }
}

// No browser and no JavaScript engine. It is in the benchmark as the control
// that shows what the browser engines are paying for - and what they buy.
sealed class ITextEngine : IEngine
{
    // pdfHTML and iText Core ship as separate packages on independent version
    // lines, so report both: pdfHTML 6.x is the add-on that runs on Core 9.x.
    public string Version =>
        typeof(HtmlConverter).Assembly.GetName().Version?.ToString() + "+core" +
        typeof(iText.Kernel.Pdf.PdfDocument).Assembly.GetName().Version?.ToString();

    public Task InitAsync() => Task.CompletedTask;

    public Task<byte[]> RenderAsync(string html) => Task.Run(() =>
    {
        using var stream = new MemoryStream();
        HtmlConverter.ConvertToPdf(html, stream);
        return stream.ToArray();
    });

    public Task DisposeAsync() => Task.CompletedTask;
}

Vertrauen

Die Tabelle basiert auf 8.960 zeitgesteuerten Renderings, 7 Engines über 4 Parallelitätsstufen mit jeweils 64 Renderings, wiederholt über 5 vollständige Durchläufe, zusammen mit 105 Kaltstart-Prozessstarts. Jede veröffentlichte Zahl ist der Median dieser 5 Durchläufe.

BibliothekLangsamster DurchlaufMedianSchnellster DurchlaufStreuung
wkhtmltopdf15,98/s16,03/s16,85/s5,5%
IronPDF40,71/s44,02/s44,31/s8,8%
iText 9 pdfHTML51,93/s54,30/s56,87/s9,5%
PuppeteerSharp14,74/s15,60/s16,21/s10,0%
Aspose.HTML32,31/s33,98/s35,71/s10,5%
Playwright .NET20,23/s20,68/s22,38/s10,6%
HtmlRenderer + PdfSharp290,68/s327,09/s429,45/s47,7%

Getestet auf: 24-Kern / 32-Thread x64 Desktop-CPU · 3,2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · zuletzt überprüft im September 2026

Der Durchsatz bei 8 gleichzeitigen Renderings variierte über die 5 Durchläufe um 5,5% bis 47,7%. Die Streuung ist bei den Engines am größten, die am schnellsten fertig sind, wo ein paar Millisekunden Planungsrauschen einen größeren Anteil an einem kurzen Rendering ausmachen, und am geringsten bei den langsamsten, wo dies nicht der Fall ist. HtmlRenderer schließt ein Rendering in 23 ms ab und variiert um 47,7%. wkhtmltopdf benötigt 486 ms und variiert um 5,5%. Jede Engine, die das Dokument korrekt gerendert hat, blieb innerhalb von 11%.

Die Durchläufe wurden auf einem ansonsten inaktiven Rechner durchgeführt, ohne dass andere Anwendungen um die Kerne konkurrierten. Das ist wichtiger, als es klingt. Eine frühere Kampagne derselben 5 Durchläufe, die auf demselben Desktop durchgeführt wurde, während gewöhnliche Anwendungen liefen, ergab einen niedrigeren Durchsatz bei 6 der 7 Engines, um zwischen 3% und 21%, wobei PuppeteerSharp und IronPDF am meisten verloren. Die Ausnahme war HtmlRenderer, das ein Rendering in wenigen Dutzend Millisekunden abschließt und auf dem ausgelasteten Rechner um 3% höher lag, was zeigt, wie wenig eine einzelne schnelle Messung aussagt. Die Reihenfolge der Engines war in beiden Kampagnen identisch, und die Reihenfolge ist das, was auf andere Hardware übertragbar ist. Die absoluten Raten sind spezifisch für diesen Rechner und werden es nicht sein.

HTML-zu-PDF-Kaltstartlatenz

Dies ist die Latenz, die die erste Anfrage nach einer Bereitstellung verursacht. Sie wird selten veröffentlicht, da die meisten Demonstrationen einen aufgewärmten Prozess verwenden.

BibliothekErstes PDF, bestes von 3Spitze während des Kaltstarts
HtmlRenderer + PdfSharp157 ms128 MB
wkhtmltopdf424 ms116 MB
IronPDF486 ms342 MB
iText 9 pdfHTML489 ms130 MB
PuppeteerSharp639 ms539 MB
Playwright .NET720 ms411 MB
Aspose.HTML1.096 ms162 MB

Getestet auf: 24-Kern / 32-Thread x64 Desktop-CPU · 3,2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · zuletzt überprüft im September 2026

IronPDF ist das schnellste zu einem ersten PDF von allem hier, das das Dokument reproduzierte, mit 486 ms gegenüber 639 ms für PuppeteerSharp und 720 ms für Playwright, und weit vor Aspose.HTML mit 1.096 ms. Das ist ein eingebettetes Chromium, das ein erstes PDF in einer halben Sekunde erreicht, gegenüber 2 Engines, die zuerst einen externen Browser starten und sich mit ihm verbinden müssen.

Die 2 Engines über ihm in der Tabelle sind diejenigen, die keinen modernen Browser zu starten haben. HtmlRenderer hat überhaupt keine Rendering-Engine dieser Art und erreicht ein erstes PDF in 157 ms. wkhtmltopdf lädt QtWebKit 5.212, weit leichter als das aktuelle Chromium, und benötigt 424 ms. beide bei etwa 120 MB gegenüber IronPDFs 342 MB, und iText 9 ist 3 ms hinter IronPDF bei 489 ms, bei 130 MB. Diese Speicherlücke ist der Preis für das Mitführen eines Browsers, und sie wird durch das begrenzt, was der Browser liefert. Die gleiche halbe Sekunde produzierte eine Rechnung mit dem Gesamtbetrag bei 0.00 und kein Diagramm auf allen 3 von ihnen, sodass die Messwerte nicht die gleiche Operation zeitlich erfassen.

Durchsatz und Latenz nach Gleichzeitigkeit

Stabiler Zustand über die 4 Ebenen der Gleichzeitigkeit hinweg.

BibliothekParallelitätDurchsatzp50p95SpitzenprozessbaumProzesse
IronPDF19.22/s96 ms181 ms750 MB6
IronPDF431.49/s121 ms149 ms850 MB10
IronPDF844.02/s161 ms269 ms1,187 MB15
IronPDF1640.16/s364 ms511 ms1,770 MB28
Playwright .NET15.93/s167 ms179 ms511 MB8
Playwright .NET416.91/s234 ms255 ms750 MB11
Playwright .NET820.68/s381 ms426 ms1,122 MB15
Playwright .NET1621.31/s724 ms870 ms1,808 MB23
PuppeteerSharp14.85/s204 ms224 ms584 MB11
PuppeteerSharp411.85/s339 ms383 ms890 MB16
PuppeteerSharp815.60/s507 ms597 ms1,293 MB24
PuppeteerSharp1615.68/s997 ms1,147 ms2,094 MB40
iText 9 pdfHTML112.69/s53 ms220 ms174 MB1
iText 9 pdfHTML445.69/s84 ms111 ms264 MB1
iText 9 pdfHTML854.30/s144 ms178 ms332 MB1
iText 9 pdfHTML1658.53/s268 ms315 ms535 MB1
HtmlRenderer + PdfSharp1143.08/s7 ms8 ms153 MB1
HtmlRenderer + PdfSharp4366.96/s11 ms14 ms157 MB1
HtmlRenderer + PdfSharp8327.09/s23 ms35 ms166 MB1
HtmlRenderer + PdfSharp16309.92/s48 ms67 ms181 MB1
wkhtmltopdf12.34/s422 ms478 ms147 MB3
wkhtmltopdf48.97/s443 ms484 ms293 MB10
wkhtmltopdf816.03/s486 ms526 ms482 MB18
wkhtmltopdf1624.09/s635 ms743 ms827 MB34
Aspose.HTML110.37/s80 ms181 ms235 MB1
Aspose.HTML433.48/s119 ms144 ms293 MB1
Aspose.HTML833.98/s227 ms299 ms334 MB1
Aspose.HTML1633.37/s469 ms581 ms398 MB1

Getestet auf: 24-Kern / 32-Thread x64 Desktop-CPU · 3,2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · zuletzt überprüft im September 2026

Liniendiagramm, das die Renderings pro Sekunde im Vergleich zum Parallelitätsgrad für 6 .NET PDF-Engines vergleicht, wobei IronPDF als die schnellste korrekte Ausgabe gekennzeichnet ist und bei 8 gleichzeitigen Renderings mit 44,02 Renderings pro Sekunde den Höchstwert erreicht, und Endpunkte bei 16 gleichzeitigen Renderings von 58,53 für iText 9 pdfHTML, das als fehlend bei den Seitensummen und dem Diagramm markiert ist, 40,16 für IronPDF, 33,37 für Aspose.HTML, 24,09 für wkhtmltopdf, 21,31 für Playwright und 15,68 für PuppeteerSharp

Unter den Engines, die das Dokument korrekt gerendert haben, führte IronPDF bei allen getesteten Parallelitätsstufen, wobei sein Vorteil bei höherer Last zunahm. Bei Parallelität 1 reichten die 3 korrekten Renderer von 4,85 bis 9,22 Renderings pro Sekunde, ein Unterschied von 1,9x. Bei Parallelität 8 reichten sie von 15,60 bis 44,02, ein Unterschied von 2,8x. Die Lücke vergrößert sich mit der Last, was eine In-Prozess-Engine von 2 unterscheidet, die jede Seite durch einen Browser bewegen müssen, den sie nicht hosten.

Die meisten Engines haben auch einen Knick, ein Niveau, ab dem der Durchsatz nicht mehr steigt und nur noch die Latenz zunimmt. IronPDF's liegt bei 8, wo 44,02/s zu 40,16/s bei 16 wird, während p50 von 161 ms auf 364 ms steigt, sodass ein Semaphore, das es bei 8 hält, den Durchsatz ohne die zusätzliche Latenz beibehält. PuppeteerSharp ist ab 8 flach, 15,60/s bis 15,68/s, während p50 von 507 ms auf 997 ms über 40 Prozesse steigt, was eine Latenz ist, die mit nichts erkauft wird. Aspose.HTML flacht noch früher ab und gewinnt zwischen 4 und 16 nichts. HtmlRenderer dreht am frühesten von allen, bei 4, was eine Ein-Prozess-Bibliothek tut, sobald die Arbeit das übersteigt, was ein Kern planen kann. iText 9, Playwright und wkhtmltopdf gewannen alle noch bei 16 und hatten innerhalb des getesteten Bereichs keinen Knick erreicht, obwohl Playwrights 21,31/s dort unter dem liegt, was IronPDF bei 4 aufrechterhielt.

Die Extrapolation von Einzel-Render-Zeiten durch Parallelität überschätzt durchweg den tatsächlichen Durchsatz, wobei der Grad je nach Engine variiert. Bei Parallelität 8 erreicht IronPDF 60% seines extrapolierten Durchsatzes, iText 53%, Playwright 44% und PuppeteerSharp 40%.

Spitzenwert des Speichers unter Last

Die gleichen Spitzenwerte wie die Sweep-Tabelle, so angeordnet, dass eine Bibliothek eine Spalte heruntergelesen wird. Diese Werte bestimmen die Containergröße.

BibliothekSpitze bei 1Spitze bei 4Spitze bei 8Spitze bei 16MB pro anhaltendem Render/s bei 8Korrekt gerendert
IronPDF750 MB850 MB1.187 MB1.770 MB27,0Ja
Playwright .NET511 MB750 MB1.122 MB1.808 MB54,3Ja
PuppeteerSharp584 MB890 MB1.293 MB2.094 MB82,9Ja
iText 9 pdfHTML174 MB264 MB332 MB535 MB6,1Nein
HtmlRenderer + PdfSharp153 MB157 MB166 MB181 MB0,5Nein
wkhtmltopdf147 MB293 MB482 MB827 MB30,1Nein
Aspose.HTML235 MB293 MB334 MB398 MB9,8Nein

Getestet auf: 24-Kern / 32-Thread x64 Desktop-CPU · 3,2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · zuletzt überprüft September 2026

Allein der Spitzenwert des Speichers kann Engines begünstigen, die weniger Arbeit leisten, was in der letzten Spalte berücksichtigt wird. Die Division des Spitzenwerts des Speichers durch den anhaltenden Durchsatz ergibt die Speicherkosten pro Render pro Sekunde. Unter den Engines, die das Dokument korrekt gerendert haben, ist IronPDF mit 27,0 MB am effizientesten, verglichen mit 54,3 MB für Playwright und 82,9 MB für PuppeteerSharp.

Die absoluten Spitzenwerte des Speichers unterscheiden sich. Playwright hält die niedrigere Spitze bei Parallelität 1, 4 und 8, um 239 MB, 100 MB und 65 MB, und gibt diesen Vorsprung bei 16 zurück, wo IronPDF bei 1.770 MB gegen Playwrights 1.808 MB liegt. Bei 8, wo der Vorsprung real ist, liefert es 20,68 Render pro Sekunde gegenüber 44,02 bei IronPDF, sodass die 65 MB, die es spart, mehr als die Hälfte des Durchsatzes kosten.

Layout-Engine-Bibliotheken haben aufgrund des Fehlens einer Browser-Engine einen deutlich geringeren Speicherverbrauch. Während dies ein echter Vorteil ist, führte es in diesem Test dazu, dass die Gesamtwerte bei 0.00 blieben.

Für die 3 Chromium-gesteuerten Engines steigt der Spitzenwert des Speichers um 49 % bis 62 % zwischen 8 und 16 gleichzeitigen Renders, ohne dass ein entsprechender Anstieg des Durchsatzes erfolgt. Der Durchsatz von IronPDF sinkt um 9 %, während PuppeteerSharp konstant bleibt und Playwright um 3 % zunimmt. Die mittlere Latenz (p50) steigt im gleichen Schritt um das 1,9- bis 2,3-fache. Zusätzlicher Speicher über 8 gleichzeitige Renders hinaus erzeugt Latenz statt Durchsatz.

PDF-Rendering-Genauigkeit

Jede Ausgabe wurde zurückgelesen, anstatt ihr zu vertrauen. Die Überprüfung extrahiert die Textebene, stimmt die Gesamtsumme der Rechnung mit einem regulären Ausdruck ab und rastert jede Seite, da ein Canvas-Diagramm keine Textebene hat und nicht allein durch Text bestätigt werden kann.

using System;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using IronPdf;

// Reads each engine's output back and reports what actually landed on the page.
// A render that finishes in 109 ms and gets the total wrong is not faster than
// one that finishes in 164 ms and gets it right - it is a different operation,
// so the timer alone cannot be trusted.
string resultsDir = "results";

Console.WriteLine($"{"Engine",-16} {"Pages",5} {"Bytes",8} {"Total",-12} Notes");
Console.WriteLine(new string('-', 62));

foreach (string path in Directory.GetFiles(resultsDir, "*-single.pdf").OrderBy(p => p))
{
    string engine = Path.GetFileNameWithoutExtension(path).Replace("-single", "");

    using PdfDocument document = PdfDocument.FromFile(path);
    string flat = Regex.Replace(document.ExtractAllText() ?? "", @"\s+", " ");

    // The document computes its totals in JavaScript. If the script never ran,
    // the placeholder zero survives into the text layer of the PDF.
    Match total = Regex.Match(flat, @"Total\s+([\d,]+\.\d{2})");
    string reported = total.Success ? total.Groups[1].Value : "not found";
    bool scriptRan = reported != "0.00" && total.Success;

    // The canvas chart has no text layer, so rasterise page two as well and
    // confirm it by eye. A missing chart cannot be detected from text alone.
    document.RasterizeToImageFiles(Path.Combine(resultsDir, engine + "-page_*.png"), 1400, 1980);

    long bytes = new FileInfo(path).Length;
    string note = scriptRan ? "" : "JavaScript did not run";
    if (!flat.Contains("Professional services")) note += " | table rows missing";

    Console.WriteLine($"{engine,-16} {document.PageCount,5} {bytes,8} {reported,-12} {note}");
}

// Output size is a fast tell, but not a sufficient one. Identical HTML produced
// 46 to 104 KB from the engines that ran the script and drew the chart, so the
// 6 KB output is missing content rather than encoding it more cleverly. It cuts
// the other way too: one engine dropped the masthead, the totals and the chart
// and still produced 46 KB, so size narrows the question without answering it.
BibliothekSeitenAusgabegrößeRechnungssummeDiagrammKopfzeile und Layout
IronPDF247.196 Bytes2313,30GezeichnetRaster intakt
Playwright .NET246.248 Bytes2313,30GezeichnetRaster intakt
PuppeteerSharp2104.011 Bytes2313,30GezeichnetRaster intakt
iText 9 pdfHTML26.145 Bytes0,00AbwesendRaster auf 1 Spalte reduziert
HtmlRenderer + PdfSharp146.419 BytesBlock abwesendAbwesendKopfzeile entfernt, Seitenumbruch verloren
wkhtmltopdf222.752 Bytes0,00AbwesendRaster auf 1 Spalte reduziert
Aspose.HTML238.780 Bytes0,00AbwesendRaster auf 1 Spalte reduziert

Getestet auf: 24-Kern / 32-Thread x64 Desktop-CPU · 3,2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · zuletzt überprüft im September 2026

7 Tafeln, die Seite 1 derselben Rechnung zeigen, gerendert von IronPDF, Playwright, PuppeteerSharp, Aspose.HTML, iText 9 pdfHTML, wkhtmltopdf und HtmlRenderer, wobei die ersten 3 einen fälligen Betrag von 2313,30 und ein intaktes Rasterkopfzeile zeigen, Aspose.HTML, iText und wkhtmltopdf 0,00 mit der Kopfzeile auf eine einzelne Spalte reduziert zeigen und HtmlRenderer die Kopfzeile vollständig fehlt

Die gleiche Seite von allen 7, im gleichen Maßstab. Die ersten 3 Tafeln berechneten die Gesamtsumme. Die anderen 4 sind diejenigen, die ein Prüfer abzeichnen würde, ohne es zu bemerken.

Die gleiche Rechnungsseite, gerendert von IronPDF oben und von iText 9 pdfHTML unten, zeigt das gezeichnete Balkendiagramm und eine Gesamtsumme von 2313,30 im ersten und das fehlende Diagramm mit der Gesamtsumme von 0,00 im zweiten

Die gleiche Rechnungsseite, gerendert von IronPDF, Playwright, Aspose.HTML und iText 9 pdfHTML, wobei die 2 Browser-Engines das Diagramm und berechnete Gesamtsummen zeigen und die 2 Layout-Engines weder noch

Die Ausgabedateigröße ist ein grober Indikator für die Vollständigkeit der Darstellung und ein fehlerhafter. Die 3 Engines, die das Skript ausführten und das Diagramm renderten, erzeugten Dateien zwischen 46 und 104 KB, und die 6 KB Ausgabe von iText 9 fehlt Inhalt, anstatt besser komprimiert zu sein. Die Heuristik versagt in die andere Richtung bei HtmlRenderer, dessen 46 KB Datei in denselben Bereich wie die korrekten Ausgaben fällt, während das Kopfteil, die Summen und das Diagramm vollständig fehlen, sodass die Dateigröße eher eine nützliche Überprüfung als eine schlüssige ist. Keiner dieser Fehler löst Ausnahmen oder Warnungen aus, und jeder dieser PDFs ist wohlgeformt und falsch.

Die 4 Engines, die es nicht geschafft haben, die Gesamtsumme zu berechnen, taten dies aus unterschiedlichen Gründen. Eine gezielte Testseite, die separat über ES5- und ES6-Unterstützung berichtet, enthüllte 3 verschiedene Kategorien.

EngineES5ES6Auswirkung auf die Testrechnung
IronPDF, PuppeteerSharp, PlaywrightLäuftLäuftSummen berechnet, Diagramm gezeichnet
wkhtmltopdf, Aspose.HTMLLäuftWirftSummen bleiben bei null, kein Diagramm
iText 9 pdfHTML, HtmlRendererKeine EngineKeine EngineiText ließ die Platzhalter-Nullen, HtmlRenderer ließ den Block fallen; kein Diagramm in beiden

Getestet auf: 24-Kern / 32-Thread x64 Desktop-CPU · 3,2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · zuletzt überprüft im September 2026

Diese Unterscheidung ist wichtig bei der Auswahl einer Bibliothek. wkhtmltopdf und Aspose.HTML führen Skripte aus, die auf einem ES5-Basis geschrieben sind und korrekte Ergebnisse berechnen, unterstützen jedoch nicht document.querySelectorAll(...).forEach, wie auf der Testseite verwendet. iText 9 und HtmlRenderer führen JavaScript auf keiner Sprachebene aus.

Hinweis: Die Darstellung von Chrome wird als Referenz verwendet, was von Natur aus Chromium-basierte Bibliotheken begünstigt. Obwohl dies eine bekannte Einschränkung ist, bleibt es für die meisten Szenarien angemessen, da in der Regel ein Abgleich der Browserausgabe erforderlich ist.


Laden Sie das HTML-zu-PDF-Benchmark-Harness und Rohdaten herunter

Ein Benchmark, den Sie nicht erneut ausführen können, ist eine Behauptung. Alles hinter den obigen Tabellen befindet sich in einem Archiv, einschließlich der Teile, die die Zahlen überprüfbar anstatt zitierbar machen.

Laden Sie das Benchmark-Paket herunter (282 KB)

OrdnerWas es enthält
harness/Das vollständige ausführbare Projekt: Engine-Adapter, Parallelitätssweep, Kaltstart-Treiber, Speichermessgerät, Treueprüfung und die Skripte, die 5 Durchläufe ausführen und den Median nehmen
fixture/invoice.htmlDie genaue Eingabe, 10.260 Zeichen, Byte für Byte, was allen 7 Engines übergeben wurde
raw-timings/35 Ergebnisdateien, 7 Engines über 5 Durchläufe, mit jedem Durchsatz pro Ebene, p50, p95, Spitzenwert Speicher und Prozessanzahl, plus die berechneten Mediane
outputs/Das PDF, das jede Engine aus diesem Fixture erzeugt hat, sodass die Genauigkeitsansprüche geöffnet anstatt geglaubt werden können

Um zu reproduzieren: dotnet build -c Release, dann ./run-isolated.sh 1 2 3 4 5, dann python median-iso.py. Führen Sie eine einzelne Engine mit --engine <id> aus, während Sie iterieren, da dies der einzige Weg ist, wie die Speicherzahlen ehrlich bleiben.

3 Dinge sind absichtlich nicht im Archiv enthalten. Lizenzschlüssel, da IronPDF IRONPDF_LICENSE_KEY aus der Umgebung liest und Aspose.HTML seine eigene .lic Datei erwartet, und beide Engines hier unter kommerziellen Lizenzen liefen. Die wkhtmltopdf.exe Binärdatei, die ein Drittanbieter-Artefakt aus den archivierten Veröffentlichungen dieses Projekts ist. Und die Browser, die PuppeteerSharp und Playwright jeweils beim ersten Lauf herunterladen.


Über den Benchmark hinaus: Wo IronPDF weiterhin führend ist

Der Benchmark betrachtet eine einzige Frage bezüglich der Geschwindigkeit und Genauigkeit, mit der 7 Engines die gleiche Rechnung konvertieren. In der Praxis haben Produktionspipelines zusätzliche Anforderungen. Der nächste Abschnitt gibt Antworten auf häufig gestellte Folgefragen.

Wie lassen sich diese Zahlen auf Linux und Container übertragen?

Alle oben genannten Zahlen wurden auf Windows 11 auf Bare-Metal-Hardware ermittelt. Faktoren wie CPU-Limits von Containern, cgroup-Speicherabrechnung und gemeinsame Hosts können die Parallelität beeinflussen. IronPDF arbeitet auf Linux und in Docker mit dem gleichen NuGet-Paket, einschließlich Chromium, sodass kein separater Browser-Download oder Playwright-Installation erforderlich ist. Dimensionieren Sie Ihren Container basierend auf der Spitzenlast bei Ihrer beabsichtigten Parallelität und fügen Sie zusätzliche Kapazität für die Laufzeit hinzu.

Warum wurde im Benchmark ein HTML-String anstelle einer Live-URL verwendet?

Der Benchmark stellte jeder Engine einen In-Memory-String zur Verfügung, um die Netzwerklatenz aus den Ergebnissen zu eliminieren. In der Produktion ist die Eingabe oft eine URL, und die Konvertierung einer URL in PDF erfordert typischerweise nur eine Methodenänderung am gleichen Renderer. Die hier getesteten Layout-Engines unterstützen dies nicht direkt. iText 9 und HtmlRenderer akzeptieren nur Markup, daher müssen Sie die Seite abrufen und eine Basis-URL festlegen, um relative Pfade aufzulösen.

Wie bekomme ich CJK-, Arabisch- oder Thai-Text korrekt in einem PDF gerendert?

Die Testrechnung verwendet einen web-sicheren lateinischen Font-Stack, um die Schriftabdeckung aus den Zeitmessungsergebnissen auszuschließen. Renderer unterscheiden sich am meisten bei nicht-lateinischen Schriften, aber die Lösung ist konsistent. Geben Sie Schriften explizit an, anstatt sich auf Vererbung zu verlassen. Betten Sie Schriften mit @font-face ein oder installieren Sie das erforderliche Schriftpaket in Ihrem Image und konsultieren Sie den Leitfaden zur Schriftverwaltung für Einbettungsregeln. Chromium-basierte Engines bieten das gleiche Shaping- und Fallback-Verhalten wie Browser.

Wie skaliert HTML zu PDF für große Dokumente und langlaufende Dienste?

Diese Ergebnisse spiegeln Spitzenwerte aus der Verarbeitung eines Stapels von 2-seitigen Rechnungen wider, nicht größerer Dokumente oder Langzeittests. Längere oder bildlastige Dokumente benötigen mehr Speicher. Für dauerhafte Arbeitslasten verwenden Sie begrenzte Parallelität. Begrenzen Sie laufende Renderings mit einem Semaphor, verwenden Sie eine einzelne Renderer-Instanz wieder, anstatt für jede Anfrage eine neue zu erstellen, und rendern Sie asynchron, sodass der Durchsatz nur durch das Parallelitätslimit begrenzt ist. Das Batch-Verarbeitungstutorial bietet eine vollständige Anleitung.

Dies ist die Phase, in der die Unterschiede zwischen den Lösungen zunehmen, anstatt abzunehmen. Der Benchmark bewertete eine einzelne Operation, nämlich das Rendering, das die Hauptfunktion der kostenlosen Engines darstellt. Die meisten Dokumentenverarbeitungspipelines erfordern jedoch zusätzliche Fähigkeiten über diesen Punkt hinaus.

  • Alles nach dem Rendern: Zusammenführen, Seitenmanipulation, Formularausfüllung, digitale Signaturen, PDF/A-Archivierung, Verschlüsselung und Berechtigungen, Textextraktion. IronPDF deckt diese im gleichen Paket ab, das das Rendering durchgeführt hat. Die Browser-Engines rendern und stoppen, sodass alles darüber hinaus eine weitere Bibliothek bedeutet, die hinzugefügt, lizenziert und erlernt werden muss.
  • Browserbetrieb und Patchen: Playwright und PuppeteerSharp schnitten in diesen Tests gut ab. Sie erfordern jedoch ein Container-Image mit Chromium, einen Browser-Download während des Builds, laufende Prozessüberwachung und Chromium-Patching während des gesamten Lebenszyklus des Dienstes. IronPDF enthält Chromium innerhalb seines NuGet-Pakets, was zu einer Kaltstartzeit von 486 ms im Vergleich zu 639 ms und 720 ms für die Alternativen führt.
  • Speicher pro Arbeitseinheit: IronPDF hält 27,0 MB pro Render pro Sekunde aufrecht, verglichen mit 54,3 MB und 82,9 MB für die Alternativen. Obwohl es höhere Lizenzkosten hat, ist es am kostengünstigsten bei typischen Dienstparallelitätsstufen zu betreiben.

Die 2 Engines mit dem höchsten Durchsatz erreichten dies, indem sie keinen Browser einbezogen, aber die resultierenden Dokumente spiegelten diese Einschränkung wider. iText 9 gab einen fälligen Betrag von 0.00 zurück, und HtmlRenderer ließ den Summenblock vollständig aus. Aspose.HTML erreichte das gleiche Ergebnis mit seiner eigenen Layout-Engine, und wkhtmltopdf mit einem QtWebKit-Build, der zu alt war, um die Seite auszuführen. Dieser Ansatz funktioniert nur, wenn das Markup statisch ist und keine dynamische Berechnung, Diagramme, berechnete Summen oder moderne Layouts erfordert. Wenn diese Funktionen vorhanden sind, zeigen die Benchmark-Ergebnisse die Einschränkungen auf.


Welche HTML-zu-PDF-Bibliothek sollten Sie verwenden?

Der Standard, für alles, was richtig herauskommen muss: IronPDF. Es rendert das Dokument korrekt mit 44,02 Renderings pro Sekunde, 2,1-mal schneller als Playwright und 2,8-mal schneller als PuppeteerSharp auf identischer Hardware, erreichte ein erstes PDF in 486 ms und lieferte die meiste Arbeit pro Megabyte der 3 Engines, die die Rechnung überhaupt reproduzierten. Chromium wird im Paket mitgeliefert, sodass kein Browser installiert, überwacht oder gepatcht werden muss, und das Zusammenführen, Formulare, Signaturen, PDF/A und Verschlüsselung sind in derselben Bibliothek enthalten, anstatt in der nächsten.

Jede der anderen 6 hat eine spezifische Einschränkung, die unten aufgeführt ist.

Playwright .NET erzeugt Chrome-ähnliche Ausgaben und kostet keine Lizenzgebühren, bei 20,68 Renderings pro Sekunde gegenüber 44,02. Die Lizenz ist nicht der einzige Kostenfaktor. Sie müssen die Browser-Binärdateien in Ihrem Image pflegen, den playwright install chromium-Schritt in Ihrem Build, einen Prozesspool, der unter Last 23 Prozesse erreicht, und das Patchen von Chromium für die Lebensdauer des Dienstes.

PuppeteerSharp reproduzierte das Dokument ebenfalls, bei 15,60 Renderings pro Sekunde, und erzeugt die meisten Prozesse von allem, was hier gemessen wurde, 40 bei 16 gleichzeitig. Sein p50 verdoppelt sich von 507 ms auf 997 ms über denselben Schritt, während der Durchsatz konstant bleibt, sodass diese zusätzlichen Prozesse Latenz statt Kapazität hinzufügen.

iText 9 mit pdfHTML ist schnell, bei 54,30 Renderings pro Sekunde, und die zurückgegebene Rechnung liest 0.00, wo die Summe hingehört. Es hat keine JavaScript-Engine auf irgendeiner Sprachebene, sodass dieses Ergebnis kein Konfigurationsproblem ist, das gelöst werden muss. Es ist AGPL oder kommerziell, daher ist es für die meisten Teams eine kostenpflichtige Bibliothek, die die Seite dennoch nicht ausführen kann.

HtmlRenderer mit PdfSharp ist das schnellste im Benchmark, bei 327,09 Renderings pro Sekunde, und das schnellste zu einem ersten PDF bei 157 ms. Seine Ausgabe ließ das Kopfteil, den Summenblock und das Diagramm weg und komprimierte 2 Seiten auf 1. Seine CSS-Unterstützung endet um 2011, sodass die Geschwindigkeit das ist, was Sie dafür bekommen, dass die Seite nicht layoutet wird.

wkhtmltopdf läuft auf einer Engine, die im Januar 2023 archiviert wurde, zuletzt im Juni 2020 veröffentlicht, auf Qt 4.8.5. Es führt ES5 aus und wirft bei ES6, weshalb die Summe 0.00 liest, und es erhält keine Sicherheitspatches. Wenn es Ihre aktuellen Vorlagen korrekt rendert, wird es dies weiterhin tun, bis sich die Vorlagen ändern.

Aspose.HTML ist eine kostenpflichtige Bibliothek ohne kostenlose Stufe, die dieselbe 0.00-Summe und das fehlende Diagramm wie die anderen Layout-Engines erzeugte und 1.096 ms zu einem ersten PDF benötigte, das langsamste gemessene. Sein Fall ist die Beschaffung, nicht das Rendering.

Für Dashboards, Diagramme oder alles, was zur Ladezeit berechnet wird: Eine browserähnliche Engine ist die einzige Kategorie, die funktioniert hat, und IronPDF ist diejenige in dieser Kategorie, die Sie nicht betreiben müssen.


HTML-zu-PDF-Fehlerbehebung: 5 Fehler und deren Behebungen

Wie verhindere ich, dass mein Diagramm im PDF leer gerendert wird?

Das PDF wird erfasst, bevor das JavaScript das Zeichnen abgeschlossen hat. Der Fehler tritt zuverlässig in der Entwicklung und intermittierend unter Produktionslast auf, was die Diagnose erschwert.

Warten Sie auf eine Bedingung anstatt auf eine feste Dauer. Jede browserbasierte Bibliothek kann das Rendern halten, bis eine Bedingung erfüllt ist, sei es, dass die Bedingung Netzwerk-Inaktivität, das Erscheinen eines benannten Elements oder ein JavaScript-Ausdruck ist, der wahr zurückgibt. Bevorzugen Sie das Element, da eine Diagrammbibliothek das Herunterladen lange vor dem Zeichnen abschließt.

// IronPDF 2026.8.1 - waiting for the page to finish drawing itself.
using IronPdf;

var renderer = new ChromePdfRenderer();

// Waiting for a specific element beats waiting for the network, because a chart
// library can finish downloading well before it finishes rendering.
renderer.RenderingOptions.WaitFor.HtmlElementById("chart-ready", maxWaitTimeInMilliseconds: 10000);

// A JavaScript condition works too when there is no element to key on.
// renderer.RenderingOptions.WaitFor.JavaScript(5000);

using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("dashboard.pdf");

Wie bringe ich CSS dazu, im PDF korrekt zu rendern?

Die Mehrheit der CSS-Rendering-Probleme kann auf 4 Hauptursachen zurückgeführt werden.

Ein häufiger Fehler ist der @media print-Block im Stylesheet, der nur während des Druck-Renderings gilt und im Browser nicht erscheint. Setzen Sie den CSS-Mediatyp explizit mit RenderingOptions.CssMediaType, um sicherzustellen, dass das richtige Stylesheet angewendet wird, anstatt sich auf den Standard zu verlassen.

Das zweite Problem sind Hintergründe und Farben, die nicht erscheinen, da Browser sie beim Drucken oft weglassen, um Tinte zu sparen. Aktivieren Sie RenderingOptions.PrintHtmlBackgrounds = true, um sie wiederherzustellen, und verwenden Sie print-color-adjust: exact im CSS für Elemente, die davon unberührt bleiben.

Die verbleibenden 2 Ursachen beziehen sich auf das Timing. Bilder können noch im Lazy-Loading sein, wenn der Schnappschuss gemacht wird, oder Webfonts sind möglicherweise nicht geladen, was dazu führt, dass der Text auf eine Systemschriftart zurückfällt und das Layout verändert. Beheben Sie diese Probleme, indem Sie sicherstellen, dass alle Ressourcen geladen sind, bevor das Rendering erfolgt.

Wie behebe ich fehlende Bilder und Stylesheets beim Rendern eines HTML-Strings?

Beim Rendern aus einem String gibt es keinen Basisstandort, sodass der Renderer relative Pfade wie /images/logo.png nicht auflösen kann. Dies ist das häufigste Problem bei der Eingabe von Strings und kann mit einer einzigen Konfiguration behoben werden.

Setzen Sie eine Basis-URL oder einen Basis-Pfad, bevor Sie rendern. Für IronPDF verwenden Sie RenderingOptions.BaseUrlOrPath. Für iText verwenden Sie ConverterProperties.SetBaseUri. Alternativ verwenden Sie im gesamten Dokument absolute URLs. Weitere Informationen zur Asset-Codierung, die möglicherweise erforderlich ist, sobald relative Pfade aufgelöst sind, finden Sie im Leitfaden zu Basis-URLs.

Wie behebe ich HTML zu PDF, das lokal funktioniert, aber in Docker fehlschlägt?

Es gibt 3 Hauptursachen, die überprüft werden müssen. Erstens, möglicherweise sind die erforderlichen Schriftarten nicht im Image installiert. Zweitens, eine native Abhängigkeit könnte fehlen. Drittens, der Browser wurde möglicherweise während des Image-Builds nicht heruntergeladen und kann zur Laufzeit nicht abgerufen werden.

Fehlende Schriftarten sind schwer zu diagnostizieren, da kein Fehler gemeldet wird. Das PDF wird gerendert, aber der Text erscheint als leere Kästchen. Installieren Sie die notwendigen Schriftpakete, anstatt den Rendering-Code zu überprüfen. Für Browser-Downloads beinhalten eingebettete Engines wie IronPDFs Chromium den Browser im Paket, wodurch ein erster Download entfällt, der aufgrund von Netzwerkbeschränkungen fehlschlagen könnte.

Wie behebe ich PDF-Text, der als Kästchen oder im falschen Skript gerendert wird?

Dieses Problem hat die gleiche Ursache wie oben, zeigt sich jedoch als spezifisches Symptom. Die erforderliche Schriftart für ein bestimmtes Skript fehlt im Container. Sprachen wie Thai, Arabisch und CJK sind am stärksten betroffen, da minimale Basis-Images oft keine Abdeckung für diese Skripte bieten.

Betten Sie die Schriftarten im Dokument mit @font-face und den Schriftdateien ein oder installieren Sie die Pakete im Image. Verlassen Sie sich nicht auf das Standardsatz der Basis-Images, das sich zwischen den Versionen ändert. Der Leitfaden zur Schriftartenverwaltung enthält die Einbettungsdetails.


Bereitstellung von HTML zu PDF in Docker

Der häufigste Fehler ist eine Konfiguration, die lokal funktioniert und im Container fehlschlägt. Die meisten Fälle werden durch 3 Korrekturen abgedeckt.

Laden Sie den Browser zur Build-Zeit herunter, nicht beim ersten Start: Wenn Ihr Image Chromium nicht enthält, löst die erste Anfrage nach der Bereitstellung einen 150 MB großen Download aus oder schlägt fehl, wenn der Egress blockiert ist.

Installieren Sie die benötigten Schriftarten und nativen Abhängigkeiten: Schlanke Basis-Images liefern einen minimalen Schriftsatz. Jedes Dokument über das lateinische Skript hinaus erfordert zusätzliche Schriftpakete.

Deaktivieren Sie nicht die Sandbox: Das Übergeben von --no-sandbox behebt den Fehler, indem Chrome als Root mit deaktivierter Sandbox ausgeführt wird. Konfigurieren Sie stattdessen einen Nicht-Root-Benutzer mit einem seccomp-Profil.

# IronPDF on Linux. The engine ships in the NuGet package, so there is no
# browser download at first run and no Chromium to supervise.
FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base
WORKDIR /app

# Chromium's Linux dependencies plus fonts. Slim base images carry neither, and
# a missing font produces empty boxes rather than an error.
RUN apt-get update && apt-get install -y --no-install-recommends \
        libnss3 libatk-bridge2.0-0 libgbm1 libasound2 libxshmfence1 \
        fonts-liberation fonts-noto-core fonts-noto-cjk \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY ["InvoiceService.csproj", "./"]
RUN dotnet restore "InvoiceService.csproj"
COPY . .
RUN dotnet publish "InvoiceService.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .

# Run as a non-root user rather than reaching for --no-sandbox.
RUN useradd --create-home --shell /usr/sbin/nologin renderer \
    && chown -R renderer:renderer /app
USER renderer

ENV IRONPDF_LICENSE_KEY=""
ENTRYPOINT ["dotnet", "InvoiceService.dll"]
SHELL

Bereitstellungskosten nach Bibliothek

Die Ressourcenallokation sollte basierend auf der beobachteten Spitzen-Speichernutzung auf der beabsichtigten Parallelitätsebene bestimmt werden. Zusätzliche Kapazität sollte eingeschlossen werden, um Laufzeit-Overhead und Anwendungsanforderungen zu berücksichtigen. Es ist ratsam, eine Instanzgröße zu wählen, die diese kombinierten Schätzungen übersteigt, um eine zuverlässige Leistung sicherzustellen.

BibliothekSpitzenwert bei 8 gleichzeitigRealistischer ContainerRendert/sec konstantKorrekt gerendert
IronPDF1.187 MB2 GB44,02Ja
Playwright .NET1.122 MB2 GB20,68Ja
PuppeteerSharp1.293 MB2 GB15,60Ja
iText 9 pdfHTML332 MB1 GB54,30Nein
HtmlRenderer + PdfSharp166 MB512 MB327,09Nein
wkhtmltopdf482 MB1 GB16,03Nein
Aspose.HTML334 MB1 GB33,98Nein

Getestet auf: 24-Kern / 32-Thread x64 Desktop-CPU · 3,2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · zuletzt überprüft September 2026

Die vergleichenden Speicherzahlen in der letzten Spalte bieten Klarheit über die Ressourcenanforderungen. Alle 3 korrekt rendernden Engines arbeiteten innerhalb eines 2 GB Containers, was den Durchsatz als den entscheidenden Unterschied und nicht den Speicherverbrauch positioniert. Ihr Durchsatz reichte von 16 bis 44 Renderings pro Sekunde, was bedeutet, dass die Auswahl von PuppeteerSharp gegenüber IronPDF fast die dreifache Infrastruktur für eine gleichwertige Ausgabe erfordern würde. Marginale Unterschiede im Spitzenwert des Speichers, wie die 65 MB Lücke zwischen Playwright und IronPDF, beeinflussen die Instanzauswahl nicht wesentlich, während Durchsatzunterschiede erhebliche Auswirkungen auf die Betriebskosten haben.

2 Dinge ändern diese Zahlen für Ihre eigene Umgebung. Die Form des Dokuments ist eine davon. Ein 200-seitiges Dokument oder ein Dokument mit vielen hochauflösenden Bildern erhöht die Spitzen-Speichernutzung weit über das hinaus, was eine 2-seitige Rechnung benötigt. Wo Sie messen, ist das andere. Führen Sie den Test innerhalb des Containers durch, in den Sie bereitstellen werden, da eine Multi-Core-Workstation und eine virtualisierte Instanz gleichzeitige Arbeiten unterschiedlich planen.


HTML zu PDF FAQ

Was ist die beste HTML zu PDF Bibliothek für C#? Basierend auf diesen Messungen war IronPDF die schnellste Engine, um das Dokument korrekt zu rendern, mit 44,02 Renderings pro Sekunde im Vergleich zu 20,68 für Playwright und 15,60 für PuppeteerSharp, und es lieferte die meiste Arbeit pro Megabyte der 3.

Wie konvertiere ich eine URL zu PDF in C#? Jede browserbasierte Bibliothek hier nimmt eine URL direkt. Übergeben Sie sie anstelle eines HTML-Strings und der Rest Ihres Codes bleibt unverändert. Die Layout-Engine-Bibliotheken, iText 9 und HtmlRenderer, tun dies nicht. Holen Sie das HTML mit HttpClient, übergeben Sie den String und setzen Sie eine Basis-URL, damit relative Assets aufgelöst werden.

Welche Bibliotheken unterstützen JavaScript? Es gibt 3 Unterstützungsstufen. IronPDF, PuppeteerSharp und Playwright führen modernes JavaScript vollständig aus. wkhtmltopdf und Aspose.HTML führen ES5 aus, werfen jedoch bei ES6 einen Fehler, sodass ein modernes Skript stillschweigend fehlschlägt und Platzhalterwerte im Output hinterlässt. iText 9 und HtmlRenderer haben überhaupt keine JavaScript-Engine.

Kann ich HTML zu PDF ohne einen Headless-Browser konvertieren? Ja. iText 9, Aspose.HTML und HtmlRenderer mit PdfSharp haben alle ihre eigenen Layout-Engines und benötigen keinen Browser. Der Kompromiss ist die JavaScript-Ausführung und die Unterstützung moderner CSS.

Wie konvertiere ich eine Razor-Ansicht zu PDF in ASP.NET Core? Rendern Sie die Ansicht zuerst zu einem String und übergeben Sie dann diesen String an jede Bibliothek hier. Der häufigste Fehler sind relative Asset-Pfade, da, sobald das HTML ein String ist, /css/site.css nichts hat, worauf es sich beziehen kann, also setzen Sie eine Basis-URL oder verwenden Sie absolute Pfade. Der Razor-to-PDF-Leitfaden behandelt die MVC- und Blazor-Varianten.

Ist wkhtmltopdf im Jahr 2026 noch verwendbar? Es funktioniert, aber es ist archiviert. Die letzte stabile Version ist wkhtmltopdf (0.12.6) von Juni 2020 auf Qt (4.8.5), und das Repository wurde im Januar 2023 archiviert. Es wird kein modernes CSS rendern und erhält keine Sicherheitspatches.

Warum sieht mein PDF anders aus als im Browser? Normalerweise ein @media print-Block, Hintergründe, die ohne print-color-adjust nicht gedruckt werden, Bilder, die immer noch lazy-loading sind, oder eine Web-Schriftart, die nicht angekommen war, als der Schnappschuss gemacht wurde.

Welche Bibliothek ist die schnellste? HtmlRenderer mit PdfSharp bei 327 Renderings pro Sekunde, bei einem Output, der eine einzelne Seite ohne Kopfzeile, ohne Summen und ohne Diagramm war. Unter den Engines, die das Dokument korrekt gerendert haben, war IronPDF mit 44,02 Renderings pro Sekunde die schnellste.

Wie viel Speicher benötigt die HTML zu PDF Konvertierung? Zwischen 166 MB und 1.293 MB bei 8 gleichzeitigen Renderings. Browserbasierte Optionen sind schwerer, und ein Großteil dieses Speichers befindet sich in Kindprozessen, daher dimensionieren Sie einen Container aus dem gesamten Prozessbaum und nicht nur aus dem .NET-Prozess.


Nächste Schritte mit IronPDF

Kein einzelner Ansatz ist in jedem Bereich überlegen. Browserbasierte Bibliotheken reproduzieren moderne Seiten genau, erfordern jedoch mehr Speicher und größere Container. Layout-Engine-Bibliotheken sind schneller und kleiner, führen jedoch kein JavaScript aus, was dazu führte, dass 4 der 7 gemessenen Outputs ohne berechnete Gesamtsumme für diese Rechnung blieben. Die beste Wahl hängt von Ihren primären Einschränkungen ab.

Wenn eine genaue Wiedergabe ohne Verwaltung eines Browserprozesses Ihre Hauptanforderung ist, war IronPDF der schnellste korrekte Renderer, der hier gemessen wurde. Seine API unterstützt auch HTML-String-Konvertierung, Razor-Ansichten, responsives CSS, benutzerdefinierte Ränder und Papiergrößen, asynchrones Rendering, PDF/A-Archivierung und digitale Signaturen ohne zusätzliche Bibliothek. Für den Einsatz in großem Umfang beziehen Sie sich auf das Batch-Processing-Tutorial für Parallelitätsmuster und konsultieren Sie den C# HTML zu PDF Bibliotheksvergleich für eine breitere Bibliotheksauswahl.

Wo Sie als nächstes hingehen, in der Reihenfolge, in der die meisten Leute es brauchen. Beginnen Sie mit dem HTML zu PDF Tutorial für die vollständige Anleitung, dann die ausführbaren HTML zu PDF Beispiele für Code, den Sie einfügen können. Die kostenlose 30-Tage-Testversion führt die oben genannten Vorlagen gegen Ihre eigenen Dokumente aus, und die Lizenzbedingungen decken ab, was Sie gegen die hier gemessenen AGPL- und MIT-Bedingungen versenden können.

Download IronPDF um zu starten. Wenn Ihre Zahlen von diesen abweichen oder Sie eine zweite Meinung zur Dimensionierung für Ihre Arbeitslast wünschen, kontaktieren Sie unser Engineering-Support-Team. IronPDF wird von Iron Software entwickelt, deren .NET-Bibliotheken auch OCR, Barcodes, Word und Excel abdecken.

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.

Mehr lesen

Verwandte Artikel