La selección de una biblioteca PDF de C# afecta a la exposición del proyecto a licencias, la flexibilidad de implementación y el coste de mantenimiento a largo plazo. La mayoría de las bibliotecas que parecen adecuadas durante la evaluación revelan limitaciones en la producción: requisitos AGPL que no esperaba, representación HTML que no coincide con su navegador o fugas de memoria que sólo aparecen en Linux.
Este artículo compara las principales opciones con ejemplos de código, documenta las compensaciones que importan en la práctica e incluye una comparación de código lado a lado generando la misma factura a través de tres bibliotecas diferentes para que pueda ver las diferencias de la API directamente.
Inicio rápido: HTML a PDF en tres líneas
Instalación a través de NuGet:
using IronPdf;
Instalar el paquete IronPDF
using IronPdf;
Genere un PDF:
using IronPdf;csharp
using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("
Hello World
");
pdf.SaveAs("output.pdf");
using IronPdf;
Funciona en Windows, Linux, macOS y Docker sin configuración adicional. El resultado coincide con Chrome porqueIronPDFincorpora el mismo motor de renderizado Chromium.
Criterios de evaluación
Antes de comparar bibliotecas, sepa qué evaluar. Estas son las preguntas que hacen aflorar los problemas de producción en una fase temprana:
Criterio
Qué hay que comprobar
Por qué es importante
Traducción HTML/CSS
Alimente sus plantillas actuales con Flexbox/Grid
La mayoría de las bibliotecas afirman ser compatibles con HTML, pero en el mejor de los casos presentan CSS 2.1
Ejecución de JavaScript
Prueba con Chart.js o contenido de tabla dinámica
Las bibliotecas sin soporte JS producen secciones en blanco
Modelo de licencia
Lea la licencia completa, no el resumen
La AGPL exige que toda la aplicación sea de código abierto
Plataformas
Despliegue en su entorno Linux/Docker/ARM64 de destino
El éxito de Windows no predice el comportamiento de Linux
Memoria bajo carga
Generación de más de 100 documentos en bucle
Las pruebas de un solo documento ocultan fugas que bloquean los servidores de producción
Precios publicados
Compruebe si el precio está en el sitio web
"Ventas por contacto" suele significar entre 15.000 y 210.000 dólares al año
Comparación de bibliotecas
IronPDF- Chromium integrado, compatibilidad total con CSS/JS
IronPDF integra Chromium directamente en el paquete NuGet. El renderizado HTML coincide con Chrome porque es el motor de Chrome. CSS Flexbox, Grid, propiedades personalizadas y JavaScriptse ejecutan como se espera.
using IronPdf;csharp
using IronPdf;
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
var pdf = renderer.RenderHtmlAsPdf(@"
Revenue
$1.2M
Users
45,230
Uptime
99.97%
");
pdf.SaveAs("dashboard.pdf");
using IronPdf;
**Desventajas a tener en cuenta:** El Chromium incrustado añade ~200MB al paquete de despliegue. Para las implantaciones estándar de servidores y contenedores, se trata de una descarga única sin impacto en el tiempo de ejecución. Para entornos con restricciones de tamaño como el plan de consumo de Azure Functions, compruebe el límite de tamaño de implementación. La primera generación de PDF en un proceso en frío tarda entre 2 y 5 segundos para la inicialización de Chromium; las siguientes generaciones se ejecutan en 100-500 ms. La memoria de referencia es de unos 150-200 MB; planifique los recursos del contenedor en consecuencia.
**Licencias:** Licencias perpetuas a partir de 749 $ (1 desarrollador). Precios publicados en [ironpdf.com](https://ironpdf.com/). Sin tarifas por documento, sin AGPL, sin umbrales de ingresos.
### iText 7 (iTextSharp) - Licencia AGPL, HTML limitado
iText es una biblioteca de manipulación de PDF con una larga historia. El complemento pdfHTML ofrece conversión de HTML a PDF, pero no utiliza un motor de navegador, sino que se aproxima a CSS 2.1 con un analizador personalizado.
Un equipo de producción de una empresa mediana de SaaS descubrió esto cuando migró sus plantillas de facturas de Razor views. Las plantillas utilizan CSS Flexbox para diseños de columnas adaptables. Tras integrar pdfHTML de iText, cada factura se presentó como una pila vertical de una sola columna. Las propiedades `display: flex`, `gap` y `justify-content` se han ignorado silenciosamente. El equipo empleó tres semanas en el desarrollo antes de darse cuenta de que pdfHTML no podía procesar el CSS existente.
**La realidad AGPL:** iText utiliza la licencia AGPL. Si su aplicación es accesible a través de la red -lo que incluye todas las aplicaciones web, API y productos SaaS-, deberá publicar todo el código fuente de su aplicación bajo la licencia AGPL. No sólo el módulo PDF. Todo. iText y su empresa matriz, Apryse, velan activamente por que así sea.
**Licencia comercial:** iText [pasó a la licencia por suscripción](https://itextpdf.com/blog/itext-news/itext-transitions-subscription-based-commercial-licenses) en 2024. Los precios no están publicados - póngase en contacto con ventas para obtener un presupuesto. Los datos de terceros sugieren entre 15.000 y 210.000 dólares anuales en función del volumen de uso.
### PdfSharp - Licencia MIT, Sin HTML
[`PdfSharp`](https://github.com/empira/PDFsharp) es realmente libre bajo la licencia MIT con 34,9 millones de descargas NuGet. La contrapartida es la capacidad: proporciona una API de dibujo basada en coordenadas sin analizador HTML, sin motor CSS y sin sistema de plantillas.
Un equipo que está creando un panel de informes eligió `PdfSharp` porque era gratuito y conocido. Pasaron cuatro meses escribiendo código de maquetación basado en coordenadas: calculando las posiciones X/Y de cada elemento de texto, dibujando los bordes de las tablas píxel a píxel y gestionando manualmente los saltos de página. Cuando finalmente compararon su resultado con lo que la misma plantilla HTML producía en un navegador, se dieron cuenta de que habían construido una versión peor de lo que una biblioteca basada en Chromium hace automáticamente.
`PdfSharp` funciona bien para fusionar PDF, añadir marcas de agua y crear documentos estructurados sencillos a partir de datos. Si no necesitas renderizar HTML, sigue siendo una opción legítima.
### QuestPDF - API elegante, sin HTML, umbral de ingresos
[QuestPDF](https://www.questpdf.com/) ofrece una API de C# fluida para crear documentos mediante programación. El diseño de la API es realmente bueno: es una de las mejores API de bibliotecas .NET de cualquier categoría.
Hay dos limitaciones importantes: QuestPDF no renderiza HTML (por diseño - se trata de una elección arquitectónica deliberada, no de una característica que falte), y la Licencia Comunitaria cubre empresas con ingresos brutos anuales inferiores a 1 millón de dólares. Una vez que su empresa cruce ese umbral, será obligatoria una [licencia comercial](https://www.questpdf.com/license/). Las empresas que se acerquen al umbral deben presupuestar esta transición antes de que sea urgente.
A pesar del claro posicionamiento de QuestPDF en contra del HTML, los desarrolladores lo descubren regularmente después de iniciar la implementación porque la biblioteca aparece en los resultados de búsqueda de "biblioteca PDF de C#" junto a bibliotecas con capacidad HTML.
### wkhtmltopdf Wrappers - CVEs abandonados, sin parches
el tiempo de wkhtmltopdf ha pasado. La organización [GitHub fue archivada en julio de 2024](https://github.com/wkhtmltopdf). El motor subyacente QtWebKit fue obsoleto por Qt en 2015. Los CVEs conocidos - incluyendo [CVE-2022-35583](https://github.com/wkhtmltopdf/wkhtmltopdf/issues/5249)(CVSS 9.8, SSRF que permite la exfiltración de credenciales de AWS) - nunca serán parcheados.
Envoltorios de C# como DinkToPdf, NReco.PdfGenerator y WkHtmlToXSharp envuelven el mismo binario abandonado. El motor de renderizado está congelado en aproximadamente la capacidad de Safari 2011: sin Flexbox, sin Grid, JavaScriptlimitado. No es una opción viable para proyectos nuevos.
### PuppeteerSharp- Renderización completa, complejidad operativa
[Puppeteer Sharp](https://github.com/hardkoded/puppeteer-sharp) controla Chrome a través de enlaces .NET. La calidad de renderizado se corresponde con Chrome porque *es* Chrome. La contrapartida es operativa: se gestionan los procesos externos del navegador, incluidas las descargas, la agrupación, la supervisión de la memoria y la recuperación de bloqueos.
using IronPdf;csharp
using PuppeteerSharp;
// Downloads ~280MB Chromium on first run
await new BrowserFetcher().DownloadAsync();
await using var browser = await Puppeteer.LaunchAsync(
new LaunchOptions { Headless = true });
await using var page = await browser.NewPageAsync();
await page.SetContentAsync(html);
return await page.PdfAsync(new PdfOptions { Format = PaperFormat.A4, PrintBackground = true });
using IronPdf;
En producción, también se necesita la agrupación de procesos del navegador, la supervisión de fugas de memoria (los procesos de Chromium pueden tener fugas), la recuperación de fallos y la limpieza de recursos. El despliegue en Docker requiere la instalación de las dependencias de Chromium, lo que supone un archivo Dockerfile considerable en comparación con una imagen .NET estándar. PuppeteerSharpes viable si su equipo puede absorber los gastos operativos.
### Aspose.PDF - Amplias funciones, problemas de memoria en Linux
Aspose.PDF ofrece una amplia funcionalidad PDF con una buena documentación. El problema más importante es la estabilidad de Linux: Asposedepende de System.Drawing.Common, que requiere libgdiplus en Linux, una biblioteca sin mantenimiento con fugas de memoria documentadas. Los informes para desarrolladores abarcan años:
> "Varias docenas de peticiones hacen que el servicio se quede sin memoria en el entorno Unix, pero esto no ocurre en el entorno basado en Windows"
> - [Foro Aspose, marzo de 2022](https://forum.aspose.com/)
Para las implantaciones solo en Windows, Asposesigue siendo capaz. Para despliegues multiplataforma o en contenedores, la dependencia System.Drawing.Common crea un riesgo continuo. El precio de la licencia comercial es de aproximadamente 999 dólares por desarrollador.
## Comparación de características
| Característica |IronPDF| iText 7 | PdfSharp | QuestPDF | wkhtmltopdf | Puppeteer| Aspose|
|---|---|---|---|---|---|---|---|
| HTML a PDF| Completo (Chromium)| Limitado (CSS 2.1)| No | No | Deprecated| Completo (Chrome)| Limitado |
| CSS Flexbox/Grid| Sí | No | No | No | No | Sí | No |
| JavaScript| Sí | No | No | No | Limitado | Sí | No |
| Linux (sin libgdiplus)| Sí | Sí | Parcial*| Sí | N/A | Sí | No |
| Despliegue de Docker| Imagen de .NET Standard| Estándar| Parcial*| Estándar| Complejo | Complejo | Requiere libgdiplus|
| Mantenimiento activo| Sí | Sí | Sí | Sí | Abandonado | Sí | Sí |
| Precios publicados| Sí ($749+)| No ($15K-$210K/año)| Gratuito (MIT)| Sí (gratuito <$1M)| Gratis | Gratuito (MIT)| Sí ($999+)|
| Licencia perpetua| Sí | No (suscripción)| N/A | N/A | N/A | N/A | Sí |
| Libre de AGPL| Sí | No (requiere comercial)| Sí | Sí | Sí | Sí | Sí |
*PdfSharp ha documentado problemas específicos de la plataforma con algunas configuraciones.
## Comparación de prestaciones
Probado en una máquina virtual en la nube de nivel medio (4 vCPU, 8 GB RAM) con una plantilla de factura HTML de 200 elementos, con un promedio de 50 iteraciones después del calentamiento:
| Escenario |IronPDF| PuppeteerSharp| iText pdfHTML| wkhtmltopdf |
|---|---|---|---|---|
| Página HTML sencilla| ~150ms| ~500ms| ~200ms| ~200ms|
| Diseño CSS complejo (Flexbox/Grid)| ~250ms| ~600ms| Fallos/Parcial| ~400ms (entrecortado)|
| Página con mucho JavaScript| ~350ms| ~800ms| Fallos| Fallos/Parcial|
| Memoria por operación| ~80MB| ~150MB| ~60 MB| ~50 MB|
| Arranque en frío (primera generación)| 2-5s| 3-8s| <1s| <1s|
iText y wkhtmltopdf muestran arranques en frío más rápidos porque no inicializan el motor del navegador, pero tampoco pueden renderizar el mismo contenido. La comparación del rendimiento sólo tiene sentido en situaciones en las que todas las bibliotecas producen resultados correctos.
## Comparación de códigos: Misma factura, tres bibliotecas
Las diferencias entre estas bibliotecas son más claras cuando se construye el mismo documento. He aquí una factura generada de tres maneras.
###IronPDF- Enfoque HTML/CSS
using IronPdf;csharp
using IronPdf;
public class InvoiceGenerator
{
public byte[] GenerateInvoice(InvoiceData data)
{
var renderer = new ChromePdfRenderer();
string html = $@"
# Invoice #{data.InvoiceNumber}
Item
Qty
Price
{string.Join("", data.Items.Select(i =>
$"
{i.Name}
{i.Quantity}
${i.Price:F2}
"))}
Total: ${data.Total:F2}
";
var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;
}
}
using IronPdf;
### QuestPDF - Enfoque de API fluido
using IronPdf;csharp
using QuestPDF.Fluent;
using QuestPDF.Infrastructure;
public class InvoiceGenerator
{
public byte[] GenerateInvoice(InvoiceData data)
{
var document = Document.Create(container =>
{
container.Page(page =>
{
page.Size(PageSizes.A4);
page.Margin(40);
page.DefaultTextStyle(x => x.FontFamily("Segoe UI"));
page.Header()
.Text($"Invoice #{data.InvoiceNumber}")
.FontSize(24).FontColor(Colors.Blue.Darken2);
page.Content().Column(column =>
{
column.Item().Table(table =>
{
table.ColumnsDefinition(cols =>
{
cols.RelativeColumn(3);
cols.RelativeColumn(1);
cols.RelativeColumn(1);
});
table.Header(header =>
{
header.Cell().Background(Colors.Blue.Medium).Padding(8)
.Text("Item").FontColor(Colors.White);
header.Cell().Background(Colors.Blue.Medium).Padding(8)
.Text("Qty").FontColor(Colors.White);
header.Cell().Background(Colors.Blue.Medium).Padding(8)
.Text("Price").FontColor(Colors.White);
});
foreach (var item in data.Items)
{
table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
.Padding(8).Text(item.Name);
table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
.Padding(8).Text(item.Quantity.ToString());
table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
.Padding(8).Text($"${item.Price:F2}");
}
});
column.Item().AlignRight().PaddingTop(20)
.Text($"Total: ${data.Total:F2}").FontSize(16).Bold();
});
});
});
using var stream = new MemoryStream();
document.GeneratePdf(stream);
return stream.ToArray();
}
}
using IronPdf;
### PdfSharp - Enfoque de dibujo por coordenadas
using IronPdf;csharp
using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
public class InvoiceGenerator
{
public byte[] GenerateInvoice(InvoiceData data)
{
var document = new PdfDocument();
var page = document.AddPage();
var gfx = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24);
var headerFont = new XFont("Arial", 12, XFontStyleEx.Bold);
var bodyFont = new XFont("Arial", 12);
double y = 40;
gfx.DrawString($"Invoice #{data.InvoiceNumber}", titleFont,
XBrushes.DarkBlue, 40, y);
y += 50;
// Table header — manually positioned
double[] colX = { 40, 300, 400 };
double rowHeight = 30;
gfx.DrawRectangle(XBrushes.SteelBlue, 40, y, 500, rowHeight);
gfx.DrawString("Item", headerFont, XBrushes.White, colX[0] + 10, y + 20);
gfx.DrawString("Qty", headerFont, XBrushes.White, colX[1] + 10, y + 20);
gfx.DrawString("Price", headerFont, XBrushes.White, colX[2] + 10, y + 20);
y += rowHeight;
// Each row drawn individually with explicit coordinates
foreach (var item in data.Items)
{
gfx.DrawRectangle(XPens.LightGray, 40, y, 500, rowHeight);
gfx.DrawString(item.Name, bodyFont, XBrushes.Black, colX[0] + 10, y + 20);
gfx.DrawString(item.Quantity.ToString(), bodyFont, XBrushes.Black, colX[1] + 10, y + 20);
gfx.DrawString($"${item.Price:F2}", bodyFont, XBrushes.Black, colX[2] + 10, y + 20);
y += rowHeight;
}
y += 20;
gfx.DrawString($"Total: ${data.Total:F2}", headerFont, XBrushes.Black, 440, y);
using var stream = new MemoryStream();
document.Save(stream);
return stream.ToArray();
}
}
using IronPdf;
La versiónIronPDFutiliza HTML/CSS, habilidades que la mayoría de los desarrolladores ya poseen. La versión QuestPDF requiere el aprendizaje de una API fluida específica del dominio, pero proporciona estructura. La versión `PdfSharp` requiere calcular manualmente la posición de cada píxel: el desplazamiento de cada columna, la altura de cada fila y el trazado individual de cada borde.
## ¿Qué biblioteca elegir?
Cuando evalúo estas bibliotecas, el árbol de decisión es sencillo:
**¿Necesita convertir HTML a PDF con CSS moderno?** Las opciones prácticas sonIronPDFo PuppeteerSharp.IronPDFmaneja Chromium internamente; PuppeteerSharprequiere que gestiones procesos externos del navegador. wkhtmltopdf no es una opción para proyectos nuevos. pdfHTML de iText no puede renderizar Flexbox o Grid.
**Crear documentos mediante programación a partir de datos, sin HTML?** La fluida API de QuestPDF es productiva y está bien diseñada. `PdfSharp` proporciona un control de nivel inferior pero requiere mucho más código para diseños equivalentes.
**Despliegue multiplataforma (Linux, Docker, nube)** IronPDF, QuestPDF y PuppeteerSharpfuncionan en Linux sin dependencias de libgdiplus. Aspose.PDF ha documentado fugas de memoria en Linux. `PdfSharp` tiene compatibilidad parcial con plataformas con problemas conocidos.
**Condiciones de licencia?** `PdfSharp` (MIT) y PuppeteerSharp(MIT) son libres sin condiciones. QuestPDF es gratuito por debajo de un millón de dólares de ingresos. iText requiere el cumplimiento de AGPL o licencia comercial ($15K-$210K/año). La licencia perpetua deIronPDFcuesta a partir de 749 dólares. Asposecuesta a partir de 999 dólares.
## Antes de comprometerse
Pruebe con su contenido real, no con "Hello World" Despliegue pronto en la plataforma de destino. Mida la memoria en más de 100 documentos, no en uno. Lea el texto completo de la licencia con su equipo jurídico. Comprueba la latencia de arranque en frío si te diriges a serverless.
[IronPDF ofrece una versión de prueba](https://ironpdf.com/) con todas las funciones para que pueda evaluar sus requisitos específicos.
