PDF 工具

C# HTML 转 PDF 库比较:性能、准确性和内存

Curtis Chau
Curtis Chau
更新: 2026年9月2日

在 C# 中有 7 种主要方法可以将 HTML 转换为 PDF,并不是所有方法都能产生相同的结果。在对 7 个引擎进行基准测试时,使用一个 2 页的发票,只有 3 个正确渲染。其他 4 个中,有 3 个在应计算总额的位置打印了 0.00,而第四个则完全省略了总额块,且没有一个引擎抛出错误或警告。这些引擎在对现代 CSS 的支持、JavaScript 执行、负载下的性能和容器大小方面各不相同。这些差异只有在查看输出后才会显现,而不是假设成功渲染就意味着内容正确。本指南为所有 7 种方法提供了可用代码和每种方法的基准数据,所有数据均在一台机器上测量。

这些库主要分为两大类,这在很大程度上解释了下面的结果。浏览器级渲染器使用完整的 Chromium 引擎。IronPDF (2026.8.1) 在包中包含 Chromium,而 PuppeteerSharp (25.8.0) 和 Playwright .NET (1.62.0) 通过 DevTools 协议控制外部浏览器。这三者复制了 Chrome 的输出,包括 CSS Grid、网络字体和基于画布的图表,但需要更多内存和更大的容器。布局引擎库,如 iText 9 with pdfHTML (6.3.3 on iText Core 9.7.0)、HtmlRenderer with PdfSharp (1.6.1) 和 Aspose.HTML (25.7.0),使用它们自己的布局引擎,体积更小且通常更快,但不支持现代 JavaScript。wkhtmltopdf (0.12.6) 是一个中间案例,使用较旧的 Qt (4.8.5) WebKit 引擎,支持 ES5 但不支持 ES6。本指南中的所有基准测试均基于在 4 个并发级别下处理相同的 2 页发票,每个 PDF 都经过准确性审查。

简短版本:IronPDF 的优势

测量日期为 2026 年 9 月 3 日,5 次通过,8,960 次计时渲染,在一台空闲的 24 核 Windows 11 桌面上运行 .NET 10。完整方法和原始数据如下,测试工具可下载。

您正在选择的内容赢家测量结果替代方案的成本
正确的文档IronPDF总计计算,图表绘制,网格完整7个中有4个返回了错误的文档且未引发错误
正确渲染的吞吐量IronPDF8个并发时44.02次渲染/秒在同一台机器上是Playwright的2.1倍,PuppeteerSharp的2.8倍
每兆字节的工作量IronPDF每持续渲染/秒27.0 MBPlaywright为54.3 MB,PuppeteerSharp为82.9 MB
正确渲染的冷启动IronPDF486毫秒到第一个PDFPuppeteerSharp为639毫秒,Playwright为720毫秒,Aspose.HTML为1,096毫秒
您操作的内容IronPDFChromium随NuGet包一起提供浏览器引擎增加了一个镜像、一个构建时下载、一个进程池和一个补丁节奏
您接下来集成的内容IronPDF合并、表单、签名、PDF/A、加密在同一个包中浏览器引擎渲染并停止,因此下一步是第二个依赖项

上表中的速度数据属于那些将文档弄错的引擎。 iText 9发布了每秒54.30次渲染,HtmlRenderer为327.09,两者都通过从不运行页面的JavaScript实现。没有生成的文档,吞吐量数据意义不大,因此这里的每个表格都有一个准确性列。

IronPDF在每次正确渲染的吞吐量上领先: 在重现文档的引擎中,IronPDF在同一台机器、同一文档和相同的等待条件下,维持了每秒44.02次渲染,相比之下是20.68和15.60,同时在3个中返回了每兆字节最多的工作量,并最快达到第一个PDF。

比以上任何发现更重要的发现: 7个库中有4个生成了看似完成但错误的PDF。在其中3个中,发票总额显示为0.00而不是2313.30。第四个,HtmlRenderer,默默地丢弃了应付金额、总计和图表。任何情况下都没有引发异常,输出中也没有任何提示。


HTML to PDF Quickstart in C#

本指南介绍了在.NET中将HTML转换为PDF的7种方法,提供了代码示例和每种方法的定量基准。

  • 适用对象: 评估HTML到PDF库的.NET开发人员,以及需要用客观数据证明其选择合理性的人。
  • 您将获得: 每种方法的工作示例,涵盖HTML字符串和实时URL,以及冷启动、吞吐量、内存使用和在一致测试文档上的渲染准确性的测量。
  • 运行环境: .NET 6及更高版本,.NET Framework 4.6.2及更高版本,以及.NET Standard 2.0。基准测试在.NET 10、Windows 11上进行,具有32个逻辑核心,处于Release模式。
  • 何时使用此方法: 当您的文档已经是HTML格式时。渲染受控标记比通过单独的绘图命令构建类似文档的PDF更高效且更可靠。
  • 技术重要性: 引擎分为两类。浏览器级渲染器使用Chromium,导致更高的内存和容器需求。布局引擎库更小更快,但不执行JavaScript。下面的基准测试量化了这些权衡。

要使用它,安装包,向渲染器提供HTML字符串,并保存生成的PDF。

  1. 1使用 IronPDF 安装 NuGet Package Manager

    PM > Install-Package IronPdf

  2. 2复制并运行这段代码。

    using IronPdf;
    
    License.LicenseKey = "YOUR-TRIAL-KEY";
    var pdf = new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Invoice INV-2026-0814</h1>");
    pdf.SaveAs("invoice.pdf");
  3. 3部署到您的生产环境中进行测试

    今天就用免费试用在您的项目中开始使用IronPDF
    arrow pointer

购买或注册30天IronPDF试用版后,在应用程序开始时输入您的许可证密钥。

IronPdf.License.LicenseKey = "KEY";

从今天开始在您的项目中使用 IronPDF 免费试用。

第一步:
arrow pointer
NuGet使用NuGet安装

PM > Install-Package IronPdf

通过在 NuGet 包管理器控制台中运行上述命令安装 IronPDF,或在 NuGet 包管理器中搜索该包。
目录

用3行代码将HTML转换为PDF

上面的快速入门示例生成了本指南中使用的测试发票的以下输出。

使用C#从HTML生成的2页PDF发票,显示了带有应付金额徽章的CSS Grid页眉、30行项目表格和用JavaScript绘制的条形图

测试文档包括一个CSS Grid页眉、一个带有斑马条纹的30行表格、一个内联SVG、一个在canvas元素上渲染的条形图,以及在加载时用JavaScript计算的总计。计算出的总计对于测试很重要,因为没有JavaScript支持的引擎生成的发票看起来完整,但显示的应付金额为0.00。这种行为出现在下面的3个库中,而第四个库则完全省略了总计块。

常见的失败场景在下面的部分中介绍。


1. IronPDF:嵌入式Chromium,无需安装浏览器

IronPDF是一个在您的应用程序中运行的Chromium渲染器通过NuGet,无需单独安装浏览器。这一区别主要影响部署,稍后在指南中讨论。

安装:

> dotnet add package IronPdf

从HTML字符串:

// 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");

从实时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");

推荐使用: 当您需要浏览器精确的PDF渲染而无需管理无头浏览器的基础设施(如进程生命周期、崩溃恢复或容器配置)时,选择IronPDF。

权衡: 它在包中包含Chromium,因此单次冷渲染的峰值内存达到342 MB,8个并发渲染时达到1,187 MB。起价为$999,而其他6个中有4个是免费的。对于一个副项目或低流量的内部工具,这个成本难以证明合理性。

性能: 486毫秒冷启动,8个并发渲染时的中位延迟为161毫秒,持续渲染速度为每秒44.02次,整个进程树的峰值内存使用量为1,187 MB。测试发票准确渲染,包括图表和总计。


2. PuppeteerSharp:用于PDF渲染的无头Chrome

PuppeteerSharp是Puppeteer的.NET移植版。它下载一个Chromium构建,通过DevTools协议控制它并生成PDF。它是免费的,采用MIT许可证,积极维护,并在此处测量为PuppeteerSharp (25.8.0)。

安装:

> dotnet add package PuppeteerSharp

从HTML字符串:

// 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
});

从实时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 });

推荐使用: 当预算限制是优先考虑的因素,并且您能够管理浏览器进程时,选择PuppeteerSharp。它使用相同的引擎,输出与Chrome相同。

权衡: 您需要负责浏览器进程管理,包括生命周期、处理崩溃后孤立的进程以及配置沙箱。初次运行下载约150 MB的Chromium,在没有出站网络访问的容器中可能会失败,因此在构建时预取浏览器。在负载下,PuppeteerSharp在测量的选项中生成最多的进程,在16个并发渲染时达到40个。

性能: 639毫秒冷启动,8个并发渲染时的中位延迟为507毫秒,持续渲染速度为每秒15.60次,整个进程树的峰值内存使用量为1,293 MB。测试发票正确渲染。

3. Playwright for .NET:浏览器级PDF渲染

Playwright for .NET是微软的浏览器自动化库。它采用类似于Puppeteer的方法,但提供了不同的API、更高效的页面隔离以及类似的部署考虑。

安装:

> dotnet add package Microsoft.Playwright

第二个命令安装浏览器二进制文件。

> playwright install chromium

省略它是CI中首次Playwright构建失败的最常见原因。

从HTML字符串:

// 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
});

从实时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 });

推荐使用: 如果您需要浏览器质量的渲染且不需要费用,并且更喜欢其API,或者您已经使用Playwright进行测试并希望避免额外的依赖项,请选择Playwright for .NET。

权衡: Playwright与Puppeteer有相同的考虑,包括在您的镜像中包含浏览器二进制文件、进程监督以及在Dockerfile中的安装步骤。它是这里测量的最稳定的引擎,但其吞吐量略高于嵌入式引擎的一半。

性能: 720毫秒冷启动,8个并发渲染时的中位延迟为381毫秒,每秒持续渲染20.68次,整个进程树的峰值内存使用量为1122 MB。测试发票被正确渲染。


4. iText 9与pdfHTML:布局引擎,无JavaScript

iText 9与pdfHTML是一个带有HTML转换附加组件的PDF库。它使用自己的布局引擎而不是浏览器,在其支持的功能内提供快速且可预测的结果,并对其之外的任何内容保持沉默。这两个包的版本是分开的。pdfHTML(6.3.3)是运行在iText Core(9.7.0)上的附加组件,这是这里测量的配对。

安装:

> dotnet add package itext.pdfhtml

注意: itext7.*包已被弃用并重命名为itext.*,这是顶级教程仍然出错的一个细节。安装itext.pdfhtml,而不是itext7.pdfhtml。包名不带版本号,因此itext.pdfhtml解析为iText 9上当前的pdfHTML版本。

从HTML字符串:

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

从实时URL: iText不直接接受URL。手动获取HTML并设置基本URI以确保相对资产正确解析。

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

推荐使用: 如果您已经将iText用于其他PDF任务或需要高级PDF操作以及HTML转换,并且希望避免使用多个库,请选择iText。

权衡: iText仅在AGPL或付费许可下可用。AGPL要求开源您的整个应用程序,这使得对于大多数发布封闭软件的团队来说,付费选项是必要的。从技术上讲,iText不执行JavaScript,并且与浏览器相比,提供的CSS支持更有限,如下方的保真度基准所示。

性能: 489毫秒冷启动,8个并发渲染时的中位延迟为144毫秒,每秒持续渲染54.30次,单个进程中的峰值内存使用量为332 MB。发票总计为0.00,图表未渲染。


5. HtmlRenderer 与 PdfSharp:纯托管,无本机二进制文件

HtmlRenderer 与 PdfSharp 是用纯托管 C# 实现的,没有本机二进制文件或浏览器依赖项,也不需要额外的容器安装。它是目前提供的选项中体积最小、速度最快的,但其 CSS 支持仅限于大约 2011 年的标准。

安装:

> dotnet add package HtmlRenderer.PdfSharp

从 HTML 字符串:

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

从实时 URL:没有直接输入 URL 的方法。手动检索 HTML 并将其作为字符串传递。

推荐使用:仅在严格禁止本机二进制文件的情况下选择 HtmlRenderer 与 PdfSharp,例如受监管或隔离的环境,并且仅用于加载时不进行任何计算的模板。它是这里提供的三个不包含本机二进制文件的选项之一,另外两个是 iText 9 和 Aspose.HTML。在此发票中,它省略了页眉、总计块和图表。

权衡:HtmlRenderer 不支持 JavaScript、Flexbox 或 CSS Grid。对于固定的简单模板,它可能足够,并且其 23 毫秒的中位延迟在单个进程中无可匹敌。然而,为现代浏览器设计的 HTML 将无法正确渲染。在测试中,它省略了 CSS Grid 页眉、总计块和图表,并将两页压缩到一页上,导致内容重叠。

HtmlRenderer 是测量中最快的引擎,但无法渲染现代 CSS。在做出决策时应考虑这两个因素。

性能:157 毫秒冷启动,8 个并发渲染时的中位延迟为 23 毫秒,每秒持续渲染 327.09 次,峰值内存使用量为 166 MB,单个进程。输出是缺少页眉、总计和图表的单页。

6. wkhtmltopdf 和 DinkToPdf:存档的 Qt WebKit

wkhtmltopdf 是一个基于较旧的 Qt WebKit 引擎的命令行工具,通常通过 .NET via DinkToPdf 集成。该引擎本身没有 NuGet 安装,因此必须作为二进制文件与您的应用程序一起发布。DinkToPdf 作为包装器,尽管存在替代方案。

从 HTML 字符串:

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

从实时 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);

项目状态: wkhtmltopdf 仓库于 2023 年 1 月存档,最后一个稳定版本(0.12.6)于 2020 年 6 月发布,基于 Qt (4.8.5)。其渲染固定在大约 2013 年的网络标准,并且不再接收安全更新。

同一发票页面由当前的 Chromium 引擎和 wkhtmltopdf 渲染,显示第一个中的条形图和计算出的总计 2313.30,而第二个中没有图表,总计为 0.00

推荐使用: 如果 wkhtmltopdf 已经在生产中使用,能够正确渲染您的文档,并且您的模板是静态的,请继续使用。没有功能需求则无需迁移。

权衡: wkhtmltopdf 无法渲染依赖于 Flexbox 或较新 CSS 特性的布局,并且不接收安全补丁。

JavaScript 支持: wkhtmltopdf 执行 ES5 JavaScript,但不支持 ES6。对此构建的直接测试成功执行了 ES5 并在 ES6 上抛出错误,因为 document.querySelectorAll(...).forEach 不受 Qt (4.8.5) 引擎支持。因此,使用此调用的测试发票显示了一个占位符总计 0.00,没有任何可见错误。编写为 ES5 基线的模板计算正确,而使用现代 JavaScript 的模板则不然。

性能: 424 毫秒冷启动,8 个并发渲染时的中位延迟为 486 毫秒,每秒持续渲染 16.03 次,整个进程树的峰值内存使用量为 482 MB。发票总计为 0.00,图表未渲染。

上述数据基于将 wkhtmltopdf.exe 作为命令行工具运行,每次渲染 1 个进程。DinkToPdf 包装器在进程中使用相同的引擎,但通过 SynchronizedConverter 序列化所有调用,限制了并发可扩展性。


7. Aspose.HTML for .NET:独立布局引擎

Aspose.HTML for .NET 拥有自己的渲染引擎,而不是浏览器,它位于一个文档套件中,该套件还涵盖了 Word、Excel 和 PowerPoint。对于已经从一个供应商处购买的团队来说,这意味着一个支持合同和一个采购订单,而不是集成多个库并跟踪单独的续订。

安装:

> dotnet add package Aspose.HTML

从 HTML 字符串:

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

从实时 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");

推荐使用: 当您已经在其他格式上标准化使用 Aspose 并希望在同一合同下进行 HTML 转换时,选择 Aspose.HTML,适用于不依赖现代 JavaScript 的模板。

权衡: 这是一个付费库,没有免费层,其渲染属于布局引擎而不是浏览器。Aspose.HTML 在专业许可证下进行了基准测试,其数据出现在下表中的每个表格中。

性能: 1,096 毫秒冷启动,8 个并发渲染时的中位延迟为 227 毫秒,每秒持续渲染 33.98 次,单个进程中的峰值内存使用量为 334 MB。发票总额为 0.00,图表未渲染。


HTML 到 PDF 基准方法:版本、机器和输入

下述每个数据都来自一台机器、一个文档和一个日期的 5 次通过的单次测试。这里列出了所有 3 个因素,以便根据其优劣再现或驳回这些数据。

测量的库版本

版本列是运行时从加载的程序集中读取的,而不是文章编写时的版本,因此如果包解析为非固定版本,这里会显示出来。

库包测试版本运行时报告的程序集引擎
IronPDFIronPdf2026.8.12026.8.0.1嵌入式 Chromium
Playwright .NETMicrosoft.Playwright1.62.01.62.0.0外部 Chromium
PuppeteerSharpPuppeteerSharp25.8.025.8.0.0外部 Chromium
iText 9 with pdfHTMLitext.pdfhtml6.3.36.3.3.0 on iText Core 9.7.0自有布局引擎
HtmlRenderer + PdfSharpHtmlRenderer.PdfSharp1.6.11.6.1.0自有布局引擎
wkhtmltopdf命令行二进制文件0.12.60.12.6QtWebKit 5.212 on Qt 4.8.5
Aspose.HTMLAspose.HTML25.7.025.7.0.0自有布局引擎

机器、运行时和日期

项目值
CPU24核/32线程 x64 台式机,3.2 GHz
内存64 GB
操作系统Windows 11 x64,版本 10.0.26200
运行时.NET 10.0.11,发布版本
机器状态空闲,无其他应用程序运行
测试日期2026年9月3日
样本大小8,960 次计时渲染:7 个引擎 x 4 个并发级别 x 64 次渲染 x 5 次通过
冷启动次数105 次:7 个引擎 x 3 次启动 x 5 次通过
报告数据5 次通过的中位数,从不取最佳情况

测试文档及其应用规则

每个引擎都接收到相同的10,260字符的HTML文档,作为字符串存储在内存中。没有引擎接收到其他引擎没有的文件路径、URL或已缓存的内容。文档可在下方下载,以便进行差异比较,而不是仅凭信任。

  • 输入是自包含的: 没有外部样式表、没有网络字体、没有远程图像。测量不依赖于网络延迟或哪个引擎缓存资源更好。
  • 每个浏览器引擎的等待条件相同: Load,而不是网络空闲。PuppeteerSharp 已弃用 SetContent 的网络空闲条件,因此 Load 是所有3个引擎都支持的唯一条件。
  • 相同的页面设置,只有1个例外: A4 和每个引擎上的打印背景。边距没有强制为一个共同值,因此每个库使用其默认值,这些默认值不同:IronPDF 在页面上有缩进,而两个外部浏览器引擎没有。这在下面的并排比较中可见。它改变了内容周围的空白量,而不是引擎计算的内容。遵循分页符的6个引擎生成了2页。HtmlRenderer 生成了1页,因为它丢失了分页符而不是因为边距。
  • 需要付费许可证的引擎都有一个: IronPDF 使用完整许可证,Aspose.HTML 使用专业版,因此都没有因试用限制而被限速或加水印。iText 在 AGPL 下运行,没有功能限制。
  • 每个引擎都获得了其文档推荐的配置: 1个渲染器或浏览器实例在渲染之间重用,Puppeteer 和 Playwright 每次渲染使用新页面,Aspose.HTML 写入 MemoryStream,因此它不支付其他引擎避免的磁盘成本。

计时边界: 计时器在调用渲染时启动,在引擎返回PDF字节时停止。它不包括引擎构建和浏览器启动,这些被单独测量为冷启动,也不包括写入磁盘,因为没有要求任何引擎执行此操作。吞吐量是成功渲染次数除以整个批次的挂钟秒数,而不是各个渲染时间的总和,因为只有前者描述了服务在负载下的交付情况。

内存定义: 峰值工作集是整个进程树的总和,每100毫秒采样一次,其中树是从基准进程按真实父子关系派生的每个进程。它是一个峰值而不是平均值,因为峰值决定了容器是否能在其最繁忙的秒内存活。浏览器引擎将大部分内存保存在生成的子进程中,因此仅测量.NET进程会美化生成最多子进程的引擎。

什么算作失败: 任何渲染返回少于500字节。失败从吞吐量分子中移除并单独报告,因此引擎不能通过返回空内容来发布高比率。在这些表格背后的35次调用中,没有引擎在任何级别记录过一次失败。


HTML到PDF基准测试摘要

以下表格中的所有速度和内存值均基于实际测量。如果某个库未被测量,表格会明确指出这一点。

库冷启动8线程时的温启动p508线程时的吞吐量8线程时的峰值内存渲染测试发票许可证
IronPDF (2026.8.1)486毫秒161毫秒44.02/秒1,187 MB正确从$999起
Playwright .NET (1.62.0)720毫秒381毫秒20.68/秒1,122 MB正确MIT
PuppeteerSharp (25.8.0)639毫秒507毫秒15.60/秒1,293 MB正确MIT
iText 9 pdfHTML (6.3.3)489毫秒144毫秒54.30/秒332 MB总计0.00,无图表AGPL或付费
HtmlRenderer + PdfSharp (1.6.1)157毫秒23毫秒327.09/秒166 MB无抬头,无总计,无图表免费,BSD
wkhtmltopdf (0.12.6)424毫秒486毫秒16.03/秒482 MB总计0.00,无图表LGPL,已归档
Aspose.HTML (25.7.0)1,096毫秒227毫秒33.98/秒334 MB总计0.00,无图表付费

测试环境:24核/32线程x64桌面CPU · 3.2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · 最后验证于2026年9月

将吞吐量数据与渲染准确性结合起来分析。在测量的7个引擎中,有4个省略了重要的渲染工作,表中最快的两个结果,iText 9的54.30/秒和HtmlRenderer的327.09/秒,均来自该组。

各引擎的完整 HTML 到 PDF 基准测试结果

以下部分提供了每个汇总表条目的详细数据。

此基准测试如何测量?

测试文档

每个引擎都渲染了相同的2页发票,如上所述。使其成为测量工具而非样本的是总计数。它们在标记中作为占位符 0.00 值传递,并在加载时通过 JavaScript 计算,因此运行脚本的引擎会将2313.30写入文本层,而未运行的引擎则保留占位符以便正则表达式找到它。

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>";
    }
}

每个数字的含义

  • 吞吐量: 成功渲染次数除以整个批次的实际时间,而不是各个渲染时间的总和。只有第一个描述了服务在并发下的交付情况。
  • 失败: 任何渲染返回少于500字节。失败从吞吐量分子中移除并单独报告,因此引擎不能通过返回空值来发布高比率。在此表背后的35次调用中,没有引擎在任何级别记录过一次失败。
  • p50 和 p95: 通过线性插值从每次渲染延迟的排序列表中获取,而不是从平均值中获取。平均值隐藏了尾部,而用户等待的是尾部。
  • 峰值内存: 在整个进程树中每100毫秒采样一次的 WorkingSet64 的高水位标记。它是峰值而不是平均值,因为峰值决定了容器是否能在最繁忙的时刻存活。
  • 冷启动: 从新进程到第一个 PDF 的时间,取3次启动中的最佳值而非中位数。任何引擎的首次启动都会吸收一次性成本,如程序集加载、浏览器下载或本地提取。这些是真实的部署成本,但不是每次启动的成本,将它们平均化会模糊两个不同的数字。
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");

控制

测试工具对每次测量应用这些控制。

  • 每个引擎在开始计时之前渲染5个文档,因此这些数据描述的是稳定状态,而不是在前几个结果中分散的预热状态。
  • GC.Collect 和 WaitForPendingFinalizers 在每个级别之前运行。
  • 每个引擎在测试工具内部完成后有6秒的稳定时间,运行器在引擎进程之间再留出8秒,因此一个引擎的子进程在下一个引擎开始之前已经退出。
  • 每个引擎在其自己的进程中进行测量。基于浏览器的引擎将大部分内存保存在生成的子进程中,这些子进程在单次渲染后仍然存在,因此在一个进程中测量两个引擎会将第一个引擎的常驻浏览器计入第二个引擎。
  • 只有当引擎完成所有4个并发级别并且结果文件命名为请求的引擎时,才记录一次通过。如果在中途失败的调用没有写入任何内容,而没有该检查,前一个引擎的文件将是被归档的文件,这会将一个引擎的数字归入另一个引擎的名称。在这次测试中,这种情况发生过一次,在IronPDF的通过中,它在16次渲染级别时失败了,该通过被重新运行而不是发布。
  • 内存是根据真实的父子关系分配的,而不是根据进程名称。一个进程在从基准进程派生时计入,通过传递方式遍历并记住,以便在启动它的子进程退出后,孙进程仍然计入。创建时间保护每个声明,因为Windows回收进程ID的速度比这些引擎通过渲染器进程的速度快。
  • 树及其内存来自每个样本的1个系统范围的快照,而不是每个进程的单独查询。依次询问操作系统每个进程无法跟上一个引擎启动和退出渲染器的速度比采样间隔快。与通过WMI进行的独立读取相比,这种方式报告了一个26个进程的Chromium树为11个。

每个引擎的配置在适配器中设置。以下每个决策都避免给任何引擎带来配置优势。

  • 每个浏览器引擎都获得相同的等待条件Load、相同的A4纸张大小和打印背景。
  • PuppeteerSharp和Playwright每次渲染都获得一个新页面,这是它们自己的文档推荐的模式,也是两种选项中更便宜的一种。
  • Aspose.HTML通过库自己的流提供程序写入MemoryStream,因此它不需要其他引擎避免的磁盘I/O。
  • wkhtmltopdf作为命令行工具运行,每次渲染通过stdin和stdout运行一个进程。
  • 需要付费许可证的两个引擎在此使用中都在一个许可证下运行,Aspose.HTML在Professional下,IronPDF在完整许可证下,因此都没有受到试用限制的节流或水印。iText在其AGPL条款下运行,这些条款带有许可义务但没有功能限制。
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;
}

置信度

该表基于8,960次定时渲染,7个引擎在4个并发级别下每个进行64次渲染,重复5次完整的传递,以及105次冷启动进程启动。每个发布的数字都是这5次传递的中位数。

库最慢的传递中位数最快的传递差距
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%

测试环境:24核/32线程 x64 桌面 CPU · 3.2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · 最后验证于2026年9月

在8个并发渲染下的吞吐量在5次传递中变化了5.5%到47.7%。差距在最快完成的引擎上最宽,因为几毫秒的调度噪声在短渲染中占比更大,而在最慢的引擎上最窄,因为它不是。HtmlRenderer在23毫秒内完成渲染,变化为47.7%。wkhtmltopdf需要486毫秒,变化为5.5%。每个正确渲染文档的引擎都保持在11%以内。

这些测试是在一台空闲的机器上运行的,没有其他应用程序与核心竞争。这比听起来更重要。之前在同一台桌面上进行的相同5次测试,当普通应用程序正在运行时,7个引擎中的6个返回的吞吐量较低,下降幅度在3%到21%之间,其中PuppeteerSharp和IronPDF损失最大。例外的是HtmlRenderer,它在几十毫秒内完成渲染,并且在繁忙的机器上提高了3%,这表明单次快速测量所能确定的内容是多么有限。两个测试中的引擎排序是相同的,而排序是可以转移到其他硬件上的。绝对速率是特定于这台机器的,不会转移。

HTML到PDF冷启动延迟

这是部署后第一个请求所需的延迟。它很少被公布,因为大多数演示使用的是已预热的进程。

库第一个PDF,3次中最佳冷启动期间峰值
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

测试环境:24核/32线程x64桌面CPU · 3.2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · 最后验证于2026年9月

IronPDF是这里所有重现文档的工具中最快生成第一个PDF的,耗时486 ms,而PuppeteerSharp为639 ms,Playwright为720 ms,远远领先于Aspose.HTML的1,096 ms。这是一个嵌入式Chromium在半秒内生成第一个PDF,而其他两个引擎必须先启动外部浏览器并连接到它。

表中上面的两个引擎是没有现代浏览器启动的。HtmlRenderer 根本没有这种类型的渲染引擎,首次生成 PDF 需要 157 毫秒。wkhtmltopdf 加载的是 QtWebKit 5.212,比当前的 Chromium 轻得多,需要 424 毫秒。两者的内存占用都在大约 120 MB,而 IronPDF 是 342 MB,iText 9 比 IronPDF 慢 3 毫秒,为 489 毫秒,占用 130 MB。这个内存差距是携带浏览器的代价,并且受限于浏览器的性能。相同的半秒内,三者生成的发票总额为 0.00,且都没有图表,因此这些读数并不是对相同操作的计时。

并发情况下的吞吐量和延迟

在四个并发级别下的稳定状态。

库并发吞吐量p50p95峰值进程树进程数
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

测试环境:24核/32线程 x64 桌面 CPU · 3.2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · 最后验证时间 2026年9月

折线图比较了6个.NET PDF引擎在不同并发级别下的每秒渲染次数,标注IronPDF为最快的正确输出,在8个并发渲染时达到每秒44.02次渲染的峰值,16个并发渲染的端点为iText 9 pdfHTML的58.53(标记为缺少页面总数和图表),IronPDF为40.16,Aspose.HTML为33.37,wkhtmltopdf为24.09,Playwright为21.31,PuppeteerSharp为15.68

在正确渲染文档的引擎中,IronPDF在所有测试的并发级别中都领先,并且在更高负载下其优势增加。在并发1时,3个正确的渲染器每秒渲染次数从4.85到9.22不等,相差1.9倍。在并发8时,它们的范围从15.60到44.02,相差2.8倍。随着负载的增加,差距扩大,这就是一个进程内引擎与两个必须通过它们不托管的浏览器移动每一页的引擎之间的区别。

大多数引擎也有一个拐点,超过这个水平后吞吐量停止上升,只有延迟增加。IronPDF的拐点在8处,44.02/s在16时变为40.16/s,而p50从161 ms上升到364 ms,因此一个信号量将其保持在8可以保持吞吐量而不增加延迟。PuppeteerSharp从8开始保持平稳,从15.60/s到15.68/s,而p50在40个进程中从507 ms上升到997 ms,这是没有任何收益的延迟。Aspose.HTML更早趋于平稳,在4到16之间没有任何增益。HtmlRenderer是所有中最早趋于平稳的,在4处,这就是一个单进程库在工作超过一个核心可以调度时所做的。iText 9、Playwright和wkhtmltopdf在16时仍在增加,并且在测试范围内没有达到拐点,尽管Playwright在21.31/s时低于IronPDF在4时的持续水平。

通过并发推断单次渲染时间始终高估实际吞吐量,程度因引擎而异。在并发8时,IronPDF实现了其推断吞吐量的60%,iText为53%,Playwright为44%,PuppeteerSharp为40%。

高负载下的峰值内存

与扫描表相同的峰值,排列方式为一个库读取一列。这些值设置容器大小。

库峰值在 1峰值在 4峰值在 8峰值在 16每秒持续渲染的 MB 在 8正确渲染
IronPDF750 MB850 MB1,187 MB1,770 MB27.0是
Playwright .NET511 MB750 MB1,122 MB1,808 MB54.3是
PuppeteerSharp584 MB890 MB1,293 MB2,094 MB82.9是
iText 9 pdfHTML174 MB264 MB332 MB535 MB6.1否
HtmlRenderer + PdfSharp153 MB157 MB166 MB181 MB0.5否
wkhtmltopdf147 MB293 MB482 MB827 MB30.1否
Aspose.HTML235 MB293 MB334 MB398 MB9.8否

测试环境:24核/32线程 x64 桌面 CPU · 3.2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · 最后验证于 2026 年 9 月

仅考虑峰值内存可能会偏向于执行较少工作的引擎,这在最后一列中得到了体现。将峰值内存除以持续吞吐量可得出每秒渲染的内存成本。在正确渲染文档的引擎中,IronPDF 以 27.0 MB 的效率最高,相比之下,Playwright 为 54.3 MB,PuppeteerSharp 为 82.9 MB。

绝对峰值内存排名有所不同。Playwright在并发1、4和8时的峰值较低,分别低239 MB、100 MB和65 MB,但在16时,IronPDF的峰值为1,770 MB,而Playwright为1,808 MB。在8时,虽然节省了65 MB,但其每秒渲染次数为20.68,而IronPDF为44.02,因此节省的65 MB导致吞吐量减少了一半以上。

布局引擎库由于没有浏览器引擎,内存使用显著降低。虽然这是一个真正的优势,但在此测试中,结果总是保持在0.00。

对于3个Chromium驱动的引擎,峰值内存在8到16个并发渲染之间增加了49%到62%,而吞吐量没有相应增加。IronPDF的吞吐量下降了9%,而PuppeteerSharp保持不变,Playwright增加了3%。中位延迟(p50)在同一阶段上升了1.9到2.3倍。超过8个并发渲染的额外内存产生的是延迟而不是吞吐量。

PDF渲染准确性

每个输出都被重新读取而不是被信任。检查提取文本层,使用正则表达式匹配发票总额,并栅格化每一页,因为画布图表没有文本层,不能仅通过文本确认。

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.
库页数输出大小发票总额图表页眉和布局
IronPDF247,196 字节2313.30已绘制网格完整
Playwright .NET246,248 字节2313.30已绘制网格完整
PuppeteerSharp2104,011 字节2313.30已绘制网格完整
iText 9 pdfHTML26,145 字节0.00缺失网格折叠为1列
HtmlRenderer + PdfSharp146,419 字节块缺失缺失页眉丢失,分页符丢失
wkhtmltopdf222,752 字节0.00缺失网格折叠为1列
Aspose.HTML238,780 字节0.00缺失网格折叠为1列

测试于:24核/32线程 x64 桌面 CPU · 3.2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · 最后验证于 2026年9月

7个面板显示由IronPDF、Playwright、PuppeteerSharp、Aspose.HTML、iText 9 pdfHTML、wkhtmltopdf和HtmlRenderer渲染的同一发票的第1页,前3个显示应付金额为2313.30且网格页眉完整,Aspose.HTML、iText和wkhtmltopdf显示0.00且页眉折叠为单列,HtmlRenderer完全缺失页眉

所有7个的同一页面,比例相同。前三个面板计算了总额。其他四个是审阅者在不注意的情况下会签署的。

由IronPDF渲染的发票页面与iText 9 pdfHTML渲染的页面对比,上图显示了绘制的条形图和总计2313.30,而下图中缺少图表,总计为0.00

由IronPDF、Playwright、Aspose.HTML和iText 9 pdfHTML渲染的发票页面对比,两个浏览器引擎显示了图表和计算的总计,而两个布局引擎则没有显示

输出文件大小是渲染完整性的一个粗略指标,但并不可靠。执行脚本并渲染图表的三个引擎生成的文件大小在46到104 KB之间,而iText 9的6 KB输出缺少内容而不是更好地压缩。这个启发式方法在HtmlRenderer上失效,其46 KB文件虽然在正确输出的范围内,但完全缺少页眉、总计和图表,因此文件大小是一个有用的检查而不是决定性的。没有这些失败会引发异常或警告,每个PDF都是格式正确但内容错误的。

未能计算总计的四个引擎是由于不同的原因。一个针对性的测试页面分别报告了对ES5和ES6支持的情况,揭示了三个不同的类别。

引擎ES5ES6对测试发票的影响
IronPDF, PuppeteerSharp, Playwright运行运行计算总计,绘制图表
wkhtmltopdf, Aspose.HTML运行抛出异常总计为零,无图表
iText 9 pdfHTML, HtmlRenderer无引擎无引擎iText保留了占位符零,HtmlRenderer删除了块;两者都没有图表

测试环境:24核/32线程x64桌面CPU · 3.2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · 最后验证于2026年9月

在选择库时,这种区别很重要。wkhtmltopdf和Aspose.HTML执行基于ES5的脚本并计算正确结果,但不支持document.querySelectorAll(...).forEach,如测试页面中使用的。iText 9和HtmlRenderer在任何语言级别上都不执行JavaScript。

注意: Chrome的渲染被用作参考,这本质上偏向于基于Chromium的库。虽然这是一个已知的限制,但对于大多数场景来说仍然是合适的,因为通常需要匹配浏览器输出。


下载HTML到PDF基准测试工具和原始数据

无法重新运行的基准测试只是一个断言。上面表格背后的所有内容都在一个压缩包中,包括使数字可验证而非仅供引用的部分。

下载基准测试包 (282 KB)

文件夹包含内容
harness/完整的可运行项目:引擎适配器、并发扫描、冷启动驱动程序、内存采样器、保真度检查,以及运行5次并取中位数的脚本
fixture/invoice.html精确的输入,10,260个字符,字节对字节地传递给所有7个引擎
raw-timings/35个结果文件,7个引擎跨5次运行,每个级别的吞吐量、p50、p95、峰值内存和进程计数,以及计算出的中位数
outputs/每个引擎从该夹具生成的PDF,因此准确性声明可以被打开而不是被相信

要重现:dotnet build -c Release,然后./run-isolated.sh 1 2 3 4 5,然后python median-iso.py。在迭代时使用--engine <id>运行单个引擎,因为这是保持内存数据真实的唯一方法。

有3件事故意不在压缩包中。许可证密钥,因为IronPDF从环境中读取IRONPDF_LICENSE_KEY,而Aspose.HTML期望其自己的.lic文件,并且这两个引擎在此处均在商业许可证下运行。wkhtmltopdf.exe二进制文件,这是该项目存档版本中的第三方工件。以及浏览器,PuppeteerSharp和Playwright在首次运行时各自下载。


超越基准测试:IronPDF仍然领先的地方

基准测试考虑了7个引擎转换相同发票的速度和准确性这一单一问题。在实践中,生产管道有其他要求。下一节提供了常见后续问题的答案。

这些数字如何转换到Linux和容器?

上述所有数据均在运行于裸机上的Windows 11上获得。诸如容器CPU限制、cgroup内存计费和共享主机等因素可能会影响并发性。IronPDF在Linux和Docker上使用相同的NuGet包运行,并包含Chromium,因此无需单独下载浏览器或安装Playwright。根据预期并发时的峰值使用情况来调整容器大小,并为运行时增加额外容量。

为什么基准测试使用 HTML 字符串而不是实时 URL?

基准测试为每个引擎提供了一个内存中的字符串,以消除网络延迟对结果的影响。在生产环境中,输入通常是一个 URL,而将 URL 转换为 PDF通常只需要在同一渲染器上更改方法。这里测试的布局引擎不直接支持这一点。iText 9 和 HtmlRenderer 仅接受标记,因此您必须获取页面并设置基本 URL 以解析相对路径。

如何在 PDF 中正确渲染 CJK、阿拉伯语或泰语文本?

测试发票使用了网络安全的拉丁字体栈,以排除字体覆盖对计时结果的影响。渲染器在非拉丁脚本上差异最大,但解决方案是一致的。明确指定字体,而不是依赖继承。使用 @font-face 嵌入字体,或在您的镜像中安装所需的字体包,并查阅字体处理指南以获取嵌入规则。基于 Chromium 的引擎提供与浏览器相同的字形和回退行为。

HTML 到 PDF 如何扩展到大型文档和长时间运行的服务?

这些结果反映了处理一批 2 页发票的峰值读数,而不是较大文档或长时间测试。较长或图像密集的文档将需要更多内存。对于持续的工作负载,使用有界并发。使用信号量限制正在进行的渲染,重用单个渲染器实例而不是为每个请求创建一个,并异步渲染,以便吞吐量仅受并发上限限制。批处理教程提供了完整的指南。

这是解决方案之间差异增加而不是减少的阶段。基准测试评估了单个操作,特别是渲染,这是免费引擎的主要功能。然而,大多数文档处理管道在此点之后需要额外的功能。

  • 渲染之后的一切: 合并、页面操作、表单填写、数字签名、PDF/A 归档、加密和权限、文本提取。IronPDF 在同一个包中涵盖了这些功能。浏览器引擎渲染并停止,因此在此点之后的任何操作都意味着需要添加、许可和学习另一个库。
  • 浏览器操作和修补: Playwright 和 PuppeteerSharp 在这些测试中表现良好。然而,它们需要一个包含 Chromium 的容器镜像、在构建期间下载浏览器、持续的进程监督以及服务生命周期中的 Chromium 修补。IronPDF 在其 NuGet 包中包含 Chromium,导致冷启动时间为 486 毫秒,而替代方案为 639 毫秒和 720 毫秒。
  • 每单位工作的内存: IronPDF 每秒每次渲染维持 27.0 MB,而替代方案为 54.3 MB 和 82.9 MB。尽管其许可证成本较高,但在典型的服务并发级别下操作成本最低。

这两个吞吐量最高的引擎通过不包含浏览器实现了这一点,但生成的文档反映了这一限制。iText 9 返回的应付款金额为0.00,而 HtmlRenderer 完全省略了总计块。Aspose.HTML 使用其自己的布局引擎达到了相同的结果,而 wkhtmltopdf 使用的 QtWebKit 构建版本太旧,无法执行页面。此方法仅在标记是静态且不需要动态计算、图表、计算总计或现代布局时有效。当这些功能存在时,基准测试结果显示了其局限性。


你应该使用哪个 HTML 到 PDF 库?

默认选择,对于任何必须正确输出的内容:IronPDF。它以每秒 44.02 次渲染正确地渲染了文档,是在相同硬件上 Playwright 的 2.1 倍和 PuppeteerSharp 的 2.8 倍,首次 PDF 在 486 毫秒内完成,并在所有能够重现发票的 3 个引擎中返回了每兆字节最多的工作量。Chromium 内置在包中,因此无需安装、监督或修补浏览器,合并、表单、签名、PDF/A 和加密都在同一个库中,而不是下一个库中。

其他 6 个库各有特定的限制,详述如下。

Playwright .NET 生成 Chrome 级别的输出,且无需许可费用,每秒渲染 20.68 次,而 IronPDF 为 44.02 次。许可并不是唯一的成本。您需要在镜像中维护浏览器二进制文件、构建中的 playwright install chromium 步骤、在负载下达到 23 个进程的进程池,以及服务生命周期内的 Chromium 补丁。

PuppeteerSharp 也重现了文档,每秒渲染 15.60 次,并在此处测量的所有内容中生成最多的进程,在 16 个并发时达到 40 个。其 p50 从 507 毫秒翻倍到 997 毫秒,而吞吐量保持不变,因此这些额外的进程增加了延迟而不是容量。

iText 9 with pdfHTML 速度很快,每秒渲染 54.30 次,返回的发票在总计位置显示 0.00。它在任何语言级别上都没有 JavaScript 引擎,因此该结果不是配置问题可以解决的。它是 AGPL 或商业的,因此对于大多数团队来说,它是一个付费库,但仍然无法运行页面。

HtmlRenderer with PdfSharp 是基准测试中最快的,每秒渲染 327.09 次,首次 PDF 在 157 毫秒内完成。其输出丢失了页眉、总计块和图表,并将 2 页压缩到 1 页。其 CSS 支持停留在 2011 年左右,因此速度是您不布局页面所获得的。

wkhtmltopdf 运行的是 2023 年 1 月存档的引擎,最后一次发布是在 2020 年 6 月,基于 Qt 4.8.5。它执行 ES5 并在 ES6 上抛出错误,这就是总计显示 0.00 的原因,并且不接收安全补丁。如果它正确渲染您当前的模板,它将继续这样做,直到模板更改。

Aspose.HTML 是一个没有免费层的付费库,生成了与其他布局引擎相同的 0.00 总计和缺失的图表,并在 1,096 毫秒内完成首次 PDF,是测量中最慢的。它的案例是采购,而不是渲染。

对于仪表板、图表或任何在加载时计算的内容:浏览器级引擎是唯一有效的类别,而 IronPDF 是该类别中您无需操作的引擎。


HTML 到 PDF 故障排除:5 种故障及其解决方法

如何防止我的图表在PDF中呈现为空白?

PDF在JavaScript完成绘制之前被捕获。此故障在开发中可以可靠地重现,并在生产负载下间歇性出现,这使得诊断变得困难。

等待一个条件而不是固定的持续时间。每个基于浏览器的库都可以保持渲染直到满足条件,无论该条件是网络不活动、命名元素出现还是JavaScript表达式返回true。优先选择元素,因为图表库在完成绘制之前就已经完成下载。

// 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");

如何使CSS在PDF中正确渲染?

大多数CSS渲染问题可归因于四个主要原因。

一个常见的疏忽是样式表中的@media print块,它仅在打印渲染期间应用,而不会在浏览器中出现。使用RenderingOptions.CssMediaType显式设置CSS媒体类型,以确保应用正确的样式表,而不是依赖默认设置。

第二个问题是背景和颜色不出现,因为浏览器在打印时通常会省略它们以节省墨水。启用RenderingOptions.PrintHtmlBackgrounds = true以恢复它们,并在CSS中使用print-color-adjust: exact用于保持不受影响的元素。

剩下的两个原因与时机有关。图像可能在快照拍摄时仍在延迟加载,或者网页字体可能尚未加载,导致文本回退到系统字体并改变布局。通过确保在渲染之前所有资源都已加载来解决这些问题。

如何修复在渲染HTML字符串时丢失的图像和样式表?

从字符串渲染时,没有基准位置,因此渲染器无法解析诸如/images/logo.png之类的相对路径。这是字符串输入最常见的问题,可以通过单一配置解决。

在渲染之前设置基准URL或基准路径。对于IronPDF,使用RenderingOptions.BaseUrlOrPath。对于iText,使用ConverterProperties.SetBaseUri。或者,在整个文档中使用绝对URL。有关资产编码的信息,请参阅基准URL指南,一旦相对路径被解析,可能需要进行编码。

如何修复在本地工作但在Docker中失败的HTML到PDF?

有三个主要原因需要检查。首先,所需的字体可能未安装在镜像中。其次,可能缺少本机依赖项。第三,浏览器可能在镜像构建期间未下载,并且无法在运行时获取。

缺少字体很难诊断,因为没有报告错误。PDF渲染,但文本显示为空框。安装必要的字体包,而不是对渲染代码进行故障排除。对于浏览器下载,嵌入式引擎如IronPDF的Chromium将浏览器包含在包中,消除了首次运行下载的需要,这可能由于网络限制而失败。

如何修复呈现为方框或错误脚本的PDF文本?

此问题与上述问题有相同的根本原因,但表现为特定症状。容器中缺少特定脚本所需的字体。泰语、阿拉伯语和CJK等语言受影响最大,因为最小的基础镜像通常缺乏对这些脚本的支持。

使用@font-face和字体文件将字体嵌入文档中,或在镜像中安装相关软件包。不要依赖基础镜像的默认字体集,因为它在不同版本之间会有所变化。字体处理指南中有嵌入的详细信息。


在Docker中部署HTML到PDF

常见的失败是本地配置正常,但在容器中失败。大多数情况可以通过3种修复方法解决。

在构建时下载浏览器,而不是首次运行时: 如果您的镜像不包含Chromium,部署后的第一个请求会触发150 MB的下载,或者如果出口被阻止则直接失败。

安装所需的字体和本机依赖项: 精简的基础镜像仅提供最小的字体集。任何超出拉丁脚本的文档都需要额外的字体包。

不要禁用沙箱: 传递--no-sandbox通过以root身份运行Chrome并关闭沙箱来解决错误。相反,应配置一个具有seccomp配置文件的非root用户。

# 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

按库的部署成本

资源分配应根据预期并发级别下观察到的峰值内存使用情况来确定。应包括额外的容量以适应运行时开销和应用程序需求。建议选择一个超过这些综合估计的实例大小,以确保可靠的性能。

库8个并发时的峰值树实际容器每秒持续渲染次数渲染正确
IronPDF1,187 MB2 GB44.02是
Playwright .NET1,122 MB2 GB20.68是
PuppeteerSharp1,293 MB2 GB15.60是
iText 9 pdfHTML332 MB1 GB54.30否
HtmlRenderer + PdfSharp166 MB512 MB327.09否
wkhtmltopdf482 MB1 GB16.03否
Aspose.HTML334 MB1 GB33.98否

测试环境:24核/32线程 x64 桌面 CPU · 3.2 GHz · 64 GB RAM · Windows 11 x64 · .NET 10 · IronPDF (2026.8.1) · 最后验证于2026年9月

最后一列中呈现的比较内存数据提供了资源需求的清晰度。所有3个正确渲染引擎都在2 GB的容器内运行,这使得吞吐量成为关键的区分因素,而不是内存消耗。它们的吞吐量范围从每秒16到44次渲染,这意味着选择PuppeteerSharp而不是IronPDF需要近3倍的基础设施来实现相同的输出。峰值内存的微小差异,如Playwright和IronPDF之间的65 MB差距,并不会实质性地影响实例选择,而吞吐量差异对运营成本有显著影响。

有两件事会改变这些数据在您自己环境中的表现。一个是文档形状。200页的声明或包含许多高分辨率图像的文档会使峰值内存远高于2页发票所需的内存。另一个是您测量的位置。在您将部署的容器内运行测试,因为多核工作站和虚拟化实例的并发工作调度方式不同。


HTML 转 PDF 常见问题解答

C# 最佳的 HTML 转 PDF 库是什么? 根据这些测量结果,IronPDF 是最快的引擎,能够正确渲染文档,每秒渲染 44.02 次,而 Playwright 为 20.68 次,PuppeteerSharp 为 15.60 次,并且在 3 个库中每兆字节返回的工作量最多。

如何在 C# 中将 URL 转换为 PDF? 这里的每个基于浏览器的库都直接接受 URL。传递它而不是 HTML 字符串,您的代码其余部分保持不变。布局引擎库 iText 9 和 HtmlRenderer 则不支持。使用 HttpClient 获取 HTML,传递字符串,并设置一个基本 URL,以便解析相对资源。

哪些库支持 JavaScript? 有 3 个支持级别。IronPDF、PuppeteerSharp 和 Playwright 完全运行现代 JavaScript。wkhtmltopdf 和 Aspose.HTML 运行 ES5,但在 ES6 上会抛出错误,因此现代脚本会静默失败,并在输出中留下占位符值。iText 9 和 HtmlRenderer 完全没有 JavaScript 引擎。

可以在没有无头浏览器的情况下将 HTML 转换为 PDF 吗? 可以。iText 9、Aspose.HTML 和使用 PdfSharp 的 HtmlRenderer 都有自己的布局引擎,不需要浏览器。权衡之处在于 JavaScript 执行和现代 CSS 支持。

如何在 ASP.NET Core 中将 Razor 视图转换为 PDF? 首先将视图渲染为字符串,然后将该字符串传递给这里的任何库。常见的失败是相对资产路径,因为一旦 HTML 是字符串,/css/site.css 就没有可解析的对象,因此设置一个基本 URL 或使用绝对路径。Razor-to-PDF 指南 涵盖了 MVC 和 Blazor 变体。

wkhtmltopdf 在 2026 年仍然可用吗? 它可以工作,但已被存档。最后一个稳定版本是 2020 年 6 月发布的 wkhtmltopdf (0.12.6),基于 Qt (4.8.5),并且仓库在 2023 年 1 月被存档。它无法渲染现代 CSS,也不接收安全补丁。

为什么我的 PDF 看起来与浏览器不同? 通常是 @media print 块,背景没有使用 print-color-adjust 打印,图像仍在延迟加载,或者在快照拍摄时网络字体尚未到达。

哪个库最快? HtmlRenderer 与 PdfSharp 每秒渲染 327 次,输出是没有页眉、总计和图表的单页。在正确渲染文档的引擎中,IronPDF 是最快的,每秒渲染 44.02 次。

HTML 转 PDF 转换需要多少内存? 在 8 个并发渲染下需要 166 MB 到 1,293 MB。基于浏览器的选项更重,且大部分内存位于子进程中,因此应根据整个进程树而不是仅 .NET 进程来调整容器大小。


使用 IronPDF 的下一步

没有一种方法在所有领域都表现出色。基于浏览器的库可以准确地再现现代页面,但需要更多的内存和更大的容器。布局引擎库更快更小,但不执行 JavaScript,这导致7个测量输出中的4个没有计算出此发票的总额。最佳选择取决于您的主要限制。

如果准确渲染而无需管理浏览器进程是您的主要需求,IronPDF 是此处测量的最快的正确渲染器。它的 API 还支持HTML 字符串转换、Razor 视图、响应式 CSS、自定义边距和纸张尺寸、异步渲染、PDF/A 存档和数字签名,无需额外的库。对于高容量使用,请参考批处理教程以获取并发模式,并查阅C# HTML 到 PDF 库比较以获得更广泛的库选择。

接下来要去哪里,按照大多数人的需求顺序。首先查看HTML 到 PDF 教程以获取完整的演练,然后是可运行的 HTML 到 PDF 示例以获取您可以粘贴的代码。免费 30 天试用可以针对您自己的文档运行上述模板,许可条款涵盖了您可以根据此处测量的 AGPL 和 MIT 条款发布的内容。

下载 IronPDF 开始。如果您的数字与这些不同,或者您想要对工作负载的大小进行第二意见,请联系我们的工程支持团队。IronPDF 由 Iron Software 构建,其 .NET 库还涵盖 OCR、条形码、Word 和 Excel。

Curtis Chau 拥有卡尔顿大学的计算机科学学士学位,专注于前端开发,精通 Node.js、TypeScript、JavaScript 和 React。他热衷于打造直观且美观的用户界面,喜欢使用现代框架并创建结构良好、视觉吸引力强的手册。

阅读更多

相关文章