La biblioteca PDF de C#
using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
Install-Package IronPdf
En las aplicaciones modernas de .NET, crear y gestionar archivos PDF es un requisito común, ya sea que estés generando informes, facturas o registros digitales. Los desarrolladores a menudo recurren a bibliotecas de PDF de terceros para esta tarea, y dos de las opciones más populares en el ecosistema .NET son IronPDF y iText 7 (el sucesor de iTextSharp).
Cada biblioteca ofrece un conjunto de herramientas potente para diferentes casos de uso. ¿Pero cuál es el más adecuado para generar un PDF a partir de un byte array en C#? Este artículo desglosa todo con comparaciones, ejemplos de código e ideas para ayudar a los desarrolladores de .NET a tomar la decisión correcta.
Ya sea que esté construyendo aplicaciones a nivel empresarial o pequeñas herramientas internas, elegir la biblioteca PDF adecuada puede ahorrarle tiempo de desarrollo y garantizar un resultado sólido. Exploremos lo que ofrece cada biblioteca.
Las bibliotecas PDF en C# permiten a los desarrolladores generar, manipular y leer archivos PDF de manera programática. Sirven para una amplia gama de casos de uso, tales como:
Firmar digitalmente PDFs
También desempeñan un papel crucial en la portabilidad de datos y el cumplimiento de estándares como PDF/A para requisitos de archivo o accesibilidad.
Entre las bibliotecas PDF de .NET disponibles, iTextSharp e IronPDF han surgido como soluciones líderes, cada una con fortalezas únicas:
Elegir entre los dos no es solo una cuestión de preferencia: afecta la productividad, el mantenimiento, el rendimiento e incluso el cumplimiento legal de licencias. Los proyectos que exigen un rápido tiempo de respuesta, cambios frecuentes en el formato o la conversión de PDF desde plantillas HTML se benefician del desarrollo rápido, mientras que las aplicaciones a nivel empresarial podrían priorizar el cumplimiento de estándares y la mantenibilidad a largo plazo.
iText 7 es el sucesor oficial de iTextSharp y ofrece una arquitectura completamente rediseñada. Es una biblioteca potente y extensible, adecuada para crear, editar y validar PDFs en industrias con alto cumplimiento normativo como la legal, financiera y gubernamental. La suite iText 7 incluye soporte para PDF/A, PDF/UA, firmas digitales, redacción y creación de formularios.
Aunque sigue siendo de código abierto bajo la licencia AGPL, la licencia comercial está disponible para proyectos propietarios.
Ideal para PDF/A, accesibilidad, cumplimiento
⚠️ Nota: Necesitarás usar itext7 para operaciones PDF básicas y puedes incluir complementos opcionales como html2pdf por separado.
Para descargar el paquete principal de iText 7 para la generación de PDF:
Install-Package itextInstall-Package itext'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package itext
También puede iText 7 a través de la pantalla del Administrador de Paquetes para Soluciones. Para hacer esto, primero debe ir al menú desplegable Herramientas, luego buscar "Administrador de paquetes NuGet > Administrar paquetes NuGet para la solución".
A continuación, simplemente busca iText 7 y haz clic en "Instalar".
using System.IO;
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIText7();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIText7()
{
using (var ms = new MemoryStream())
{
PdfWriter writer = new PdfWriter(ms);
var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
Document doc = new Document(pdf);
doc.Add(new Paragraph("Hello from iText 7 for .NET!"));
doc.Close(); // Always close the document to finalize content
return ms.ToArray();
}
}
}using System.IO;
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIText7();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIText7()
{
using (var ms = new MemoryStream())
{
PdfWriter writer = new PdfWriter(ms);
var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
Document doc = new Document(pdf);
doc.Add(new Paragraph("Hello from iText 7 for .NET!"));
doc.Close(); // Always close the document to finalize content
return ms.ToArray();
}
}
}Imports System.IO
Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfWithIText7()
' Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfWithIText7() As Byte()
Using ms = New MemoryStream()
Dim writer As New PdfWriter(ms)
Dim pdf = New iText.Kernel.Pdf.PdfDocument(writer)
Dim doc As New Document(pdf)
doc.Add(New Paragraph("Hello from iText 7 for .NET!"))
doc.Close() ' Always close the document to finalize content
Return ms.ToArray()
End Using
End Function
End ClassArchivo PDF de salida
Explicación
Después de llamar a doc.Close(), el contenido del PDF se escribe completamente y está listo para ser devuelto como un arreglo de bytes.
Este ejemplo muestra la API más modular y legible de iText 7 en comparación con iTextSharp. Sin embargo, aún carece de soporte nativo para renderizar HTML/CSS a menos que incluyas pdfhtml, que se licencia por separado.
Ventajas:
Control integral de PDF
iText 7 proporciona control completo sobre los elementos PDF, como tablas, formularios y firmas digitales. Esto lo hace ideal para aplicaciones con estrictos requisitos de cumplimiento que requieren estándares específicos de PDF, como PDF/A o PDF/UA.
Modular y escalable
iText 7 es modular, lo que significa que puedes instalar solo los módulos específicos que necesites (por ejemplo, pdfhtml para la conversión de HTML a PDF). Esto permite una implementación más ligera si no estás utilizando todas las funciones.
Soporta estándares PDF complejos
iText 7 admite estándares ISO como PDF/A (archivo), PDF/UA (accesibilidad) y PDF/X (impresión), lo que lo hace adecuado para entornos profesionales y legales donde el cumplimiento es crucial.
Documentación rica y soporte
iText 7 tiene documentación completa y una gran comunidad. La empresa también ofrece soporte profesional, asegurando que los desarrolladores puedan obtener asistencia cuando lo necesiten.
Versión gratuita disponible (AGPL)
Los desarrolladores pueden usar iText 7 de forma gratuita bajo la licencia AGPL, lo cual es ideal para proyectos de código abierto o uso personal.
Contras:
Licencia AGPL para Uso Comercial
Si bien iText 7 ofrece una versión gratuita, los usuarios comerciales deben cumplir con la licencia AGPL, la cual requiere liberar el código fuente de cualquier software que utilice iText 7 o pagar por una licencia comercial.
Curva de aprendizaje pronunciada
La API de iText 7 es más compleja y rica en funciones, lo que puede resultar en una curva de aprendizaje más pronunciada en comparación con bibliotecas más simples como IronPDF. Los desarrolladores necesitan familiarizarse con su estructura de documento de bajo nivel y la arquitectura basada en módulos.
Peso pesado para tareas simples
iText 7 puede parecer engorroso para tareas básicas de PDF, como la creación simple de documentos o la conversión básica de HTML a PDF, especialmente en comparación con bibliotecas como IronPDF, que simplifican el proceso.
Requiere módulos externos para HTML a PDF
La conversión de HTML a PDF en iText 7 solo está disponible a través del módulo adicional pdfhtml, que requiere una instalación por separado y puede no manejar contenido web moderno tan perfectamente como IronPDF.
IronPDF es una biblioteca de .NET de alto nivel diseñada para simplificar la generación de documentos PDF con un enfoque en la productividad del desarrollador. Es particularmente efectivo para renderizar contenido y estilos HTML, lo que lo hace ideal para flujos de trabajo modernos de web a PDF.
IronPDF también se puede instalar a través de NuGet, ejecutando el siguiente comando en la Consola del Administrador de Paquetes NuGet:
Install-Package IronPdfInstall-Package IronPdf'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf
Alternativamente, puede instalarlo a través del administrador de paquetes NuGet para la pantalla de Solución. Para hacerlo, navega a "Herramientas > Administrador de paquetes NuGet > Administrar paquetes NuGet para la solución".
Luego, busca IronPDF, y haz clic en "Instalar".
Después de la instalación, puedes comenzar a renderizar páginas HTML completas en PDF en segundos, sin módulos adicionales necesarios. Admite CSS moderno, JavaScript e incluso contenido web interactivo sin configuración adicional.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIronPdf()
{
var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
return pdfDoc.BinaryData;
}
}using IronPdf;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIronPdf()
{
var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
return pdfDoc.BinaryData;
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfWithIronPdf()
' Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfWithIronPdf() As Byte()
Dim renderer = New ChromePdfRenderer()
Dim pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
Return pdfDoc.BinaryData
End Function
End ClassArchivo PDF de salida
Explicación
Ventajas:
Renderizado de HTML a PDF sin esfuerzo
Renderiza contenido HTML, CSS y JavaScript directamente en PDFs con estilo completo, incluyendo Bootstrap y fuentes personalizadas—sin necesidad de código de diseño complejo o módulos adicionales.
Inicio Rápido y API Intuitiva
Cree archivos PDF completamente estilizados en solo unas pocas líneas de código, con sintaxis limpia y compatibilidad total con .NET Core y .NET Framework.
Soporte Integral para Tecnologías Web
IronPDF es compatible con JavaScript, CSS moderno, SVG y consultas de medios, algo con lo que la mayoría de las bibliotecas tienen problemas a menos que utilicen navegadores sin cabeza como Chromium (que IronPDF utiliza internamente).
Manejo Incorporado de Imágenes y Recursos
Incluye fácilmente imágenes, archivos locales o incluso extrae recursos de URLs remotas sin configuración adicional.
Licenciamiento perpetuo y sin AGPL
A diferencia de iText 7, IronPDF ofrece licencias comerciales flexibles sin las restricciones de las obligaciones de AGPL de código abierto.
Excelente para vistas MVC y Razor
Convierte sin problemas las vistas Razor .cshtml en aplicaciones ASP.NET en PDFs imprimibles.
Contras:
El uso comercial requiere licencia
Aunque hay una prueba gratuita, IronPDF no es de código abierto. Los proyectos con presupuestos ajustados pueden necesitar evaluar los costos de licencia.
Tamaño de Paquete Inicial Más Grande
Dado que incluye un motor Chromium sin cabeza, el paquete NuGet es más pesado que algunas alternativas.
Los siguientes ejemplos de código en esta sección demuestran estas bibliotecas en acción, durante las cuales compararemos IronPDF e iText 7 utilizando las mismas tareas. Ambas bibliotecas se someterán a los mismos escenarios: generar un PDF desde una URL, renderizar una imagen como PDF y convertir HTML con estilo a PDF, todo mientras se utilizan matrices de bytes para gestionar nuestro contenido PDF. Esto permitirá a los desarrolladores evaluar cómo cada biblioteca aborda estos casos de uso comunes.
using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfFromUrlWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfFromUrlWithIronPdf()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(5000);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
var pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
return pdf.BinaryData;
}
}using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfFromUrlWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfFromUrlWithIronPdf()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(5000);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
var pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
return pdf.BinaryData;
}
}Imports IronPdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfFromUrlWithIronPdf()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfFromUrlWithIronPdf() As Byte()
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.JavaScript(5000)
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
Dim pdf = renderer.RenderUrlAsPdf("https://www.apple.com")
Return pdf.BinaryData
End Function
End ClassGenerar PDF
✅ IronPDF utiliza un motor de Chromium sin cabeza para el renderizado perfecto de píxeles de páginas web con soporte completo de JavaScript y CSS.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using System.Net.Http;
using System.Threading.Tasks;
using iText.Html2pdf;
class Program
{
static async Task Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = await pdfGenerator.GeneratePdfFromUrlWithIText7Async();
// Save the PDF to a file
File.WriteAllBytes("itext7-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public async Task<byte[]> GeneratePdfFromUrlWithIText7Async()
{
using var httpClient = new HttpClient();
string html = await httpClient.GetStringAsync("https://www.apple.com");
using var stream = new MemoryStream();
HtmlConverter.ConvertToPdf(html, stream);
return stream.ToArray();
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using System.Net.Http;
using System.Threading.Tasks;
using iText.Html2pdf;
class Program
{
static async Task Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = await pdfGenerator.GeneratePdfFromUrlWithIText7Async();
// Save the PDF to a file
File.WriteAllBytes("itext7-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public async Task<byte[]> GeneratePdfFromUrlWithIText7Async()
{
using var httpClient = new HttpClient();
string html = await httpClient.GetStringAsync("https://www.apple.com");
using var stream = new MemoryStream();
HtmlConverter.ConvertToPdf(html, stream);
return stream.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports System.Net.Http
Imports System.Threading.Tasks
Imports iText.Html2pdf
Friend Class Program
Shared Async Function Main(ByVal args() As String) As Task
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = Await pdfGenerator.GeneratePdfFromUrlWithIText7Async()
' Save the PDF to a file
File.WriteAllBytes("itext7-from-url.pdf", pdfBytes)
End Function
End Class
Friend Class PdfGenerator
Public Async Function GeneratePdfFromUrlWithIText7Async() As Task(Of Byte())
Dim httpClient As New HttpClient()
Dim html As String = Await httpClient.GetStringAsync("https://www.apple.com")
Dim stream = New MemoryStream()
HtmlConverter.ConvertToPdf(html, stream)
Return stream.ToArray()
End Function
End ClassSalida
⚠️ iText 7 obtiene HTML sin procesar con el HttpClient y lo renderiza usando HtmlConverter, pero no soporta JavaScript y tiene estilos CSS limitados.
using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
var pdf = ImageToPdfConverter.ImageToPdf("example.png");
return pdf.BinaryData;
}
}using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
var pdf = ImageToPdfConverter.ImageToPdf("example.png");
return pdf.BinaryData;
}
}Imports IronPdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreatePdfWithImage()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreatePdfWithImage() As Byte()
Dim pdf = ImageToPdfConverter.ImageToPdf("example.png")
Return pdf.BinaryData
End Function
End ClassSalida
✅ Generación fácil de imágenes a PDF con la herramienta ImageToPdfConverter de IronPDF. Con esto, puedes crear fácilmente archivos PDF a partir de imágenes como archivos PNG o JPG.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("iText-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
using var ms = new MemoryStream();
using var writer = new PdfWriter(ms);
using var pdfDoc = new iText.Kernel.Pdf.PdfDocument(writer);
var document = new Document(pdfDoc);
var img = new Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"));
document.Add(img);
document.Close();
return ms.ToArray();
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("iText-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
using var ms = new MemoryStream();
using var writer = new PdfWriter(ms);
using var pdfDoc = new iText.Kernel.Pdf.PdfDocument(writer);
var document = new Document(pdfDoc);
var img = new Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"));
document.Add(img);
document.Close();
return ms.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreatePdfWithImage()
' Save the PDF to a file
File.WriteAllBytes("iText-with-image.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreatePdfWithImage() As Byte()
Dim ms = New MemoryStream()
Dim writer = New PdfWriter(ms)
Dim pdfDoc = New iText.Kernel.Pdf.PdfDocument(writer)
Dim document As New Document(pdfDoc)
Dim img = New Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"))
document.Add(img)
document.Close()
Return ms.ToArray()
End Function
End ClassSalida
🟡 Creación manual del diseño del documento e inserción explícita de imágenes utilizando ImageDataFactory.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to IronPDF</h1>
<p>This is a simple PDF document generated using IronPDF.</p>
</body>
</html>";
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
return pdf.BinaryData;
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to IronPDF</h1>
<p>This is a simple PDF document generated using IronPDF.</p>
</body>
</html>";
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
return pdf.BinaryData;
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreateStyledPdf()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreateStyledPdf() As Byte()
Dim html As String = "
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to IronPDF</h1>
<p>This is a simple PDF document generated using IronPDF.</p>
</body>
</html>"
Dim pdf = (New ChromePdfRenderer()).RenderHtmlAsPdf(html)
Return pdf.BinaryData
End Function
End ClassSalida
✅ IronPDF admite completamente CSS en etiquetas o hojas de estilo externas gracias a su motor de Chromium.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
using iText.Html2pdf;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the new document to the specified file location
File.WriteAllBytes("iText-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to iText 7</h1>
<p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
</body>
</html>";
using var ms = new MemoryStream();
ConverterProperties properties = new ConverterProperties();
HtmlConverter.ConvertToPdf(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties);
return ms.ToArray();
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
using iText.Html2pdf;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the new document to the specified file location
File.WriteAllBytes("iText-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to iText 7</h1>
<p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
</body>
</html>";
using var ms = new MemoryStream();
ConverterProperties properties = new ConverterProperties();
HtmlConverter.ConvertToPdf(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties);
return ms.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO
Imports iText.Html2pdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreateStyledPdf()
' Save the new document to the specified file location
File.WriteAllBytes("iText-styled-html.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreateStyledPdf() As Byte()
Dim html As String = "
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to iText 7</h1>
<p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
</body>
</html>"
Dim ms = New MemoryStream()
Dim properties As New ConverterProperties()
HtmlConverter.ConvertToPdf(New MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties)
Return ms.ToArray()
End Function
End ClassSalida
⚠️Requiere la instalación del complemento de pago pdfHTML para poder manejar tareas de conversión de HTML.
Característica IronPDF iText 7 (con pdfHTML)
Renderizar URL a PDF ✅ Renderizado completo de Chromium ⚠️ Obtener HTML, sin soporte nativo para JS
Agregar Imagen ✅ Integrar a través de HTML o su herramienta dedicada de stampación de imágenes ✅ Fábrica de imágenes manual
Renderizar HTML con estilo ✅ Compatibilidad completa con CSS ⚠️ Soporte CSS solo a través de pdfHTML
Devuelve matriz de bytes ✅ Sí ✅ Sí
Complejidad de Configuración ⭐ Simple ⭐⭐ Moderado (diseño manual)
Calidad de Salida ⭐⭐⭐⭐⭐ Perfección de píxeles ⭐⭐⭐ Bueno pero estático
Elegir entre IronPDF y iText 7 depende de las necesidades de tu proyecto, pero cuando se trata de experiencia del desarrollador, facilidad de uso y precisión de renderizado moderno, IronPDF destaca claramente.
Si estás trabajando con contenido HTML dinámico, renderizado web o necesitas crear archivos PDF a partir de URLs con soporte completo para JavaScript y CSS, el motor basado en Chromium de IronPDF ofrece una fidelidad inigualable. Su API intuitiva y su rápida configuración lo hacen ideal para el desarrollo rápido y el uso en producción real, especialmente cuando se trabaja con matrices de bytes, flujos de archivos o generación de PDF basada en la web.
Por otro lado, iText 7 es una biblioteca potente y muy respetada con un enfoque más tradicional basado en el diseño. Ofrece un control sólido sobre la estructura del documento y es excelente para los desarrolladores que necesitan una manipulación detallada, pero tiene una curva de aprendizaje más pronunciada y carece de capacidades modernas de renderización de HTML.
En resumen:
¿Necesita herramientas de creación de PDF a nivel bajo con control granular? iText 7 podría ser la opción adecuada.
🚀 ¿Listo para comenzar con IronPDF?
Descargue la prueba gratuita y vea lo fácil que es crear PDFs profesionales basados en arreglos de bytes en C# con solo unas pocas líneas de código.
Install-Package IronPdf
No se necesita tarjeta de crédito
Su clave de prueba debería estar en el correo electrónico.
El formulario de prueba se ha enviado
exitosamente.
Si no es así, por favor contacte
support@ironsoftware.com
No se necesita tarjeta de crédito
Empezar GRATIS
No se necesita tarjeta de crédito
Pruebe en producción sin marcas de agua.
Funciona donde lo necesite.
Obtén 30 días de producto totalmente funcional.
Ténlo en funcionamiento en minutos.
Acceso completo a nuestro equipo de asistencia técnica durante la prueba del producto
No se necesita tarjeta de crédito ni crear una cuenta
Su clave de prueba debería estar en el correo electrónico.
Si no es así, por favor contacte con
support@ironsoftware.com
Empezar GRATIS
No se necesita tarjeta de crédito
Pruebe en producción sin marcas de agua.
Funciona donde lo necesite.
Obtén 30 días de producto totalmente funcional.
Ténlo en funcionamiento en minutos.
Acceso completo a nuestro equipo de asistencia técnica durante la prueba del producto
Licencias desde $749. ¿Tiene alguna pregunta? Póngase en contacto.
Reserve una demostración personal de 30 minutos.
Sin contrato, sin detalles de tarjeta, sin compromisos.
10 productos API de .NET para tus documentos de oficina
