IronPDF ofrece capacidades completas de visualización de PDF en C# con su API intuitiva y conversión de HTML a PDF utilizando un motor de renderizado basado en Chrome, mientras que PDFsharp proporciona una manipulación básica de PDF de código abierto que requiere un código significativamente más complejo para las tareas de extracción y visualización de texto.
En el desarrollo de software, el manejo de datos en diversos formatos es crucial. PDF (formato de documento portátil) es un estándar ampliamente utilizado para compartir documentos. En la programación en C#, visualizar archivos PDF es esencial para crear documentos profesionales y administrar contenido digital . La biblioteca IronPDF proporciona herramientas completas para la generación y manipulación de PDF .
La versatilidad de C# lo hace popular para desarrollar aplicaciones en diversos dominios. PDF garantiza la integridad del documento y una presentación consistente en todas las plataformas. La integración de capacidades de visualización de PDF en sus aplicaciones le permite mejorar las experiencias de los usuarios , simplificar los flujos de trabajo y brindar soluciones eficientes para el manejo de documentos. Para aplicaciones que requieren reconocimiento de texto de documentos escaneados , las soluciones de OCR complementarias pueden mejorar sus capacidades de procesamiento de PDF. La documentación de IronPDF ofrece guías de implementación completas. Al trabajar con documentos seguros , el manejo adecuado de archivos PDF se vuelve fundamental.
Este artículo explora la visualización de archivos PDF usando C#, presenta dos bibliotecas ( PDFsharp e IronPDF ) y proporciona instrucciones sobre cómo instalarlas y usarlas. Examinará las diferencias arquitectónicas, la complejidad del código y las consideraciones de mantenimiento que afectan su elección entre estas soluciones de generación de PDF . Para los entornos que requieren seguridad de documentos , comprender estas diferencias es crucial. Las demostraciones de IronPDF muestran implementaciones del mundo real, mientras que la referencia de API proporciona especificaciones detalladas.
PDFsharp es una biblioteca de código abierto para C# que ofrece a los desarrolladores un conjunto de herramientas para la manipulación de PDF. A diferencia del motor de renderizado basado en Chrome de IronPDF , PDFsharp opera en un modelo de dibujo de bajo nivel que proporciona control directo sobre los primitivos PDF. La biblioteca le permite acceder y manipular estructuras de documentos PDF . Sin embargo, en comparación con las características completas de IronPDF , PDFsharp requiere mucha más codificación manual para tareas comunes.
La arquitectura de PDFsharp sigue un enfoque de modelo de objetos de documento donde se trabaja directamente con objetos PDF. Esto difiere del enfoque de conversión de HTML a PDF de IronPDF , que utiliza tecnologías web para la generación de documentos. Si bien PDFsharp se destaca en la creación de PDF en blanco y en operaciones de dibujo, requiere más código para tareas como agregar encabezados o incrustar imágenes . Las funciones avanzadas como la representación de JavaScript , la compatibilidad con CSS responsivo y la integración de fuentes web no están disponibles en PDFsharp.
Similar al proceso de instalación de IronPDF , PDFsharp se puede instalar usando NuGet. Ejecute el siguiente comando:
Este comando instala la biblioteca PDFsharp para usarla en su proyecto. A diferencia de las opciones de instalación avanzadas de IronPDF , PDFsharp carece de soporte integrado para contenedores Docker o implementaciones de Linux . La guía de inicio rápido proporciona instrucciones de configuración adicionales para IronPDF.
PDFsharp apunta a versiones anteriores de .NET Framework y puede enfrentar problemas de compatibilidad con versiones más nuevas de .NET y entornos de nube. La biblioteca requiere una configuración manual para la implementación multiplataforma, a diferencia de la detección automática de plataforma de IronPDF. Los patrones de uso de memoria difieren y PDFsharp potencialmente consume más recursos para operaciones complejas. En escenarios de alto rendimiento , estas diferencias se hacen notorias. La guía de rendimiento de IronPDF proporciona estrategias de optimización que no están disponibles con PDFsharp.
La arquitectura de bajo nivel de PDFsharp afecta el rendimiento a través de la manipulación directa de objetos PDF, lo que requiere más ciclos de CPU. La biblioteca carece de optimización para el procesamiento por lotes, operaciones paralelas o flujos de trabajo asincrónicos. El rendimiento de la extracción de texto se degrada con documentos complejos debido al análisis manual del operador. El motor basado en Chrome de IronPDF utiliza técnicas de optimización del navegador, lo que da como resultado una representación más rápida y una mejor eficiencia de la memoria. Para las operaciones asincrónicas , la arquitectura de IronPDF ofrece ventajas significativas.
IronPDF es una biblioteca repleta de funciones que le permite manejar archivos PDF con facilidad. Diseñado con simplicidad y versatilidad, IronPDF le permite crear, editar y leer documentos PDF dentro de sus aplicaciones. Además de las capacidades fundamentales, IronPDF ofrece funciones avanzadas como conversión de HTML a PDF , compatibilidad con varios formatos de imagen y manejo eficiente de operaciones PDF . La biblioteca se destaca por generar informes PDF y convertir diferentes formatos de archivos .
La base arquitectónica de IronPDF utiliza su motor de renderizado Chrome , lo que garantiza una representación perfecta en píxeles del contenido web. Este enfoque simplifica tareas comunes como la administración de fuentes , el manejo de JavaScript y la compatibilidad con caracteres UTF-8 . La biblioteca admite linealización , compresión de PDF , firmas digitales y anotaciones .
IronPDF maneja archivos PDF y formatea datos con soporte para extracción de metadatos y operaciones asincrónicas . Para las aplicaciones Blazor , IronPDF ofrece una integración fluida.
Instale IronPDF mediante el Administrador de paquetes NuGet o la Consola del administrador de paquetes:
Este comando instala IronPDF y sus dependencias. Para implementaciones de Docker o entornos Linux , es posible que se requieran paquetes adicionales. La guía de inicio rápido proporciona instrucciones de configuración.
La API de IronPDF sigue patrones .NET modernos con interfaces fluidas y soporte asincrónico. La biblioteca proporciona nombres de métodos intuitivos y documentación completa IntelliSense. Los mensajes de error proporcionan soluciones prácticas y aceleran el desarrollo. La referencia de API ofrece detalles completos del método.
Utilice el motor Chrome de IronPDF para convertir diseños HTML adaptables, renderizar contenido JavaScript o procesar diseños CSS modernos. El motor maneja fuentes web, gráficos SVG y elementos Canvas automáticamente. Es ideal para generar facturas a partir de plantillas HTML o crear informes con visualizaciones. Para renderizar contenido WebGL , el motor proporciona aceleración de GPU.
Esta sección muestra cómo visualizar archivos PDF con PDFsharp. La extracción de texto en PDFsharp es compleja debido a su naturaleza de bajo nivel, a diferencia de los métodos simples de IronPDF :
using System;
using System.Text;
using PdfSharp.Pdf;
using PdfSharp.Pdf.IO;
using PdfSharp.Pdf.Content;
using PdfSharp.Pdf.Content.Objects;
class Program
{
static void Main()
{
// Specify the path to the PDF file
string pdfFilePath = "output.pdf";
// Open the PDF document in import mode
// Note: PDFsharp requires specific open modes for different operations
PdfDocument document = PdfReader.Open(pdfFilePath, PdfDocumentOpenMode.Import);
// Create StringBuilder for extracted text
// This approach is less efficient than IronPDF's built-in methods
StringBuilder extractedText = new StringBuilder();
// Iterate through each page of the document
for (int pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
{
// Get the current page
PdfPage page = document.Pages[pageIndex];
// Extract text using content reader (simplified approach)
// Real implementation requires extensive operator parsing
CObject content = ContentReader.ReadContent(page);
// Parse content objects to extract text
// This is where PDFsharp becomes significantly complex
ExtractText(content, extractedText);
// Note: Actual text extraction requires parsing operators
// This is a simplified representation
Console.WriteLine($"Page {pageIndex + 1} processed");
}
Console.WriteLine("Extracted Text: " + extractedText.ToString());
Console.ReadLine(); // Wait for user input before closing the console
}
static void ExtractText(CObject content, StringBuilder text)
{
// PDFsharp requires manual parsing of content streams
// This is significantly more complex than shown here
// Real implementation would need to handle:
// - Text operators (Tj, TJ, ', ", etc.)
// - Font encoding and character mapping
// - Text positioning and transformation matrices
// - Unicode mapping and glyph substitution
// - Whitespace detection and word boundaries
if (content is CArray array)
{
foreach (var item in array)
{
ExtractText(item, text);
}
}
else if (content is CString str)
{
// Simplified text extraction - real implementation needs encoding handling
text.Append(str.Value);
}
// Additional operators would need handling for complete extraction
}
}Imports System
Imports System.Text
Imports PdfSharp.Pdf
Imports PdfSharp.Pdf.IO
Imports PdfSharp.Pdf.Content
Imports PdfSharp.Pdf.Content.Objects
Module Program
Sub Main()
' Specify the path to the PDF file
Dim pdfFilePath As String = "output.pdf"
' Open the PDF document in import mode
' Note: PDFsharp requires specific open modes for different operations
Dim document As PdfDocument = PdfReader.Open(pdfFilePath, PdfDocumentOpenMode.Import)
' Create StringBuilder for extracted text
' This approach is less efficient than IronPDF's built-in methods
Dim extractedText As New StringBuilder()
' Iterate through each page of the document
For pageIndex As Integer = 0 To document.PageCount - 1
' Get the current page
Dim page As PdfPage = document.Pages(pageIndex)
' Extract text using content reader (simplified approach)
' Real implementation requires extensive operator parsing
Dim content As CObject = ContentReader.ReadContent(page)
' Parse content objects to extract text
' This is where PDFsharp becomes significantly complex
ExtractText(content, extractedText)
' Note: Actual text extraction requires parsing operators
' This is a simplified representation
Console.WriteLine($"Page {pageIndex + 1} processed")
Next
Console.WriteLine("Extracted Text: " & extractedText.ToString())
Console.ReadLine() ' Wait for user input before closing the console
End Sub
Sub ExtractText(content As CObject, text As StringBuilder)
' PDFsharp requires manual parsing of content streams
' This is significantly more complex than shown here
' Real implementation would need to handle:
' - Text operators (Tj, TJ, ', ", etc.)
' - Font encoding and character mapping
' - Text positioning and transformation matrices
' - Unicode mapping and glyph substitution
' - Whitespace detection and word boundaries
If TypeOf content Is CArray Then
For Each item In DirectCast(content, CArray)
ExtractText(item, text)
Next
ElseIf TypeOf content Is CString Then
' Simplified text extraction - real implementation needs encoding handling
text.Append(DirectCast(content, CString).Value)
End If
' Additional operators would need handling for complete extraction
End Sub
End ModuleEste código usa PDFsharp para leer y extraer texto de un archivo PDF. El programa abre "output.pdf" en modo de importación y recorre las páginas para extraer el contenido. A diferencia de la API sencilla de IronPDF , este enfoque requiere comprender los aspectos internos del PDF. Los ejemplos de extracción de texto de IronPDF demuestran un enfoque más simple.
La complejidad de PDFsharp proviene de su enfoque de bajo nivel. A diferencia de la API de alto nivel de IronPDF , PDFsharp requiere que usted comprenda los aspectos internos del PDF, incluidos los operadores, la codificación y los flujos de contenido:
// PDFsharp: Complex font handling and text positioning
PdfDocument document = new PdfDocument();
PdfPage page = document.AddPage();
XGraphics gfx = XGraphics.FromPdfPage(page);
// Must manually specify fonts and handle font embedding
XFont font = new XFont("Arial", 12, XFontStyle.Regular);
// Manual text positioning with exact coordinates
gfx.DrawString("Hello World", font, XBrushes.Black,
new XRect(0, 0, page.Width, page.Height),
XStringFormats.Center);
// Must handle coordinate transformations manually
gfx.TranslateTransform(100, 200);
gfx.RotateTransform(45);
gfx.DrawString("Rotated Text", font, XBrushes.Red, 0, 0);
// IronPDF: Simple HTML approach with CSS styling
var renderer = new ChromePdfRenderer();
var doc = renderer.RenderHtmlAsPdf(@"
<h1 style='text-align: center;'>Hello World</h1>
<p style='transform: rotate(45deg); margin-left: 100px; margin-top: 200px; color: red;'>
Rotated Text
</p>");
// IronPDF automatically handles fonts, positioning, and transformations' PDFsharp: Complex font handling and text positioning
Dim document As New PdfDocument()
Dim page As PdfPage = document.AddPage()
Dim gfx As XGraphics = XGraphics.FromPdfPage(page)
' Must manually specify fonts and handle font embedding
Dim font As New XFont("Arial", 12, XFontStyle.Regular)
' Manual text positioning with exact coordinates
gfx.DrawString("Hello World", font, XBrushes.Black, New XRect(0, 0, page.Width, page.Height), XStringFormats.Center)
' Must handle coordinate transformations manually
gfx.TranslateTransform(100, 200)
gfx.RotateTransform(45)
gfx.DrawString("Rotated Text", font, XBrushes.Red, 0, 0)
' IronPDF: Simple HTML approach with CSS styling
Dim renderer As New ChromePdfRenderer()
Dim doc = renderer.RenderHtmlAsPdf("
<h1 style='text-align: center;'>Hello World</h1>
<p style='transform: rotate(45deg); margin-left: 100px; margin-top: 200px; color: red;'>
Rotated Text
</p>")
' IronPDF automatically handles fonts, positioning, and transformationsEsta diferencia arquitectónica impacta significativamente el mantenimiento. PDFsharp requiere más código repetitivo para tareas comunes como agregar marcas de agua o administrar la orientación de la página .
Las limitaciones de PDFsharp se hacen evidentes cuando se trata con los requisitos de PDF modernos:
PDFsharp carga archivos PDF completos en la memoria, lo que puede causar problemas con archivos grandes. El procesamiento de flujo no es totalmente compatible, lo que limita la escalabilidad. A diferencia del proceso de renderizado mejorado de IronPDF, PDFsharp carece de mecanismos de almacenamiento en caché integrados. La guía de optimización del rendimiento proporciona estrategias que no están disponibles con PDFsharp.
Para visualizar archivos PDF con IronPDF solo se necesitan unas pocas líneas de código. La biblioteca administra las URL base y la codificación de activos automáticamente:
using IronPdf;
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// Load the PDF document with error handling
var pdf = PdfDocument.FromFile("output.pdf");
// Extract all the text content from the PDF
string text = pdf.ExtractAllText();
// Print the extracted text to the console
Console.WriteLine("Full document text:");
Console.WriteLine(text);
// Additional extraction options demonstrating IronPDF's versatility
// Extract text from specific pages with formatting preserved
string pageText = pdf.ExtractTextFromPage(0);
Console.WriteLine($"\nPage 1 text: {pageText}");
// Extract all images and save them
var images = pdf.ExtractAllImages();
for (int i = 0; i < images.Count; i++)
{
images[i].SaveAs($"extracted_image_{i}.png");
}
// Access complete metadata
string author = pdf.MetaData.Author;
string title = pdf.MetaData.Title;
string subject = pdf.MetaData.Subject;
DateTime creationDate = pdf.MetaData.CreationDate;
Console.WriteLine($"\nDocument Info:");
Console.WriteLine($"Title: {title}");
Console.WriteLine($"Author: {author}");
Console.WriteLine($"Created: {creationDate}");
// Search for specific text
var searchResults = pdf.Search("invoice");
foreach (var result in searchResults)
{
Console.WriteLine($"Found '{result.Text}' on page {result.PageIndex}");
}
// Extract form field data
var form = pdf.Form;
foreach (var field in form.Fields)
{
Console.WriteLine($"Field: {field.Name} = {field.Value}");
}
}
}Imports IronPdf
Imports System
Imports System.Collections.Generic
Class Program
Shared Sub Main()
' Load the PDF document with error handling
Dim pdf = PdfDocument.FromFile("output.pdf")
' Extract all the text content from the PDF
Dim text As String = pdf.ExtractAllText()
' Print the extracted text to the console
Console.WriteLine("Full document text:")
Console.WriteLine(text)
' Additional extraction options demonstrating IronPDF's versatility
' Extract text from specific pages with formatting preserved
Dim pageText As String = pdf.ExtractTextFromPage(0)
Console.WriteLine(vbCrLf & "Page 1 text: " & pageText)
' Extract all images and save them
Dim images = pdf.ExtractAllImages()
For i As Integer = 0 To images.Count - 1
images(i).SaveAs($"extracted_image_{i}.png")
Next
' Access complete metadata
Dim author As String = pdf.MetaData.Author
Dim title As String = pdf.MetaData.Title
Dim subject As String = pdf.MetaData.Subject
Dim creationDate As DateTime = pdf.MetaData.CreationDate
Console.WriteLine(vbCrLf & "Document Info:")
Console.WriteLine("Title: " & title)
Console.WriteLine("Author: " & author)
Console.WriteLine("Created: " & creationDate)
' Search for specific text
Dim searchResults = pdf.Search("invoice")
For Each result In searchResults
Console.WriteLine($"Found '{result.Text}' on page {result.PageIndex}")
Next
' Extract form field data
Dim form = pdf.Form
For Each field In form.Fields
Console.WriteLine($"Field: {field.Name} = {field.Value}")
Next
End Sub
End ClassEste código utiliza IronPDF para extraer texto de "output.pdf" usando el método ExtractAllText. La implementación gestiona automáticamente la complejidad de los PDF, lo que ofrece claras ventajas sobre el análisis manual que requiere PDFsharp. Su aplicación puede usar esta función inmediatamente sin necesidad de comprender los aspectos internos de los PDF. El tutorial completo proporciona ejemplos adicionales.
IronPDF proporciona herramientas completas para el análisis de PDF:
// Advanced PDF analysis with IronPDF
var pdf = PdfDocument.FromFile("complex-document.pdf");
// Extract structured content with detailed information
foreach (var page in pdf.Pages)
{
// Get page dimensions for layout analysis
var width = page.Width;
var height = page.Height;
var rotation = page.Rotation;
// Extract form fields with type information
var formFields = page.GetFormFields();
foreach (var field in formFields)
{
Console.WriteLine($"Field: {field.Name}, Type: {field.Type}, Value: {field.Value}");
}
// Extract annotations with properties
var annotations = page.GetAnnotations();
foreach (var annotation in annotations)
{
Console.WriteLine($"Annotation: {annotation.Title} - {annotation.Content}");
}
// Extract hyperlinks with destinations
var links = page.GetLinks();
foreach (var link in links)
{
Console.WriteLine($"Link: {link.Text} -> {link.Url}");
}
}
// Advanced search functionality with context
var searchResults = pdf.Search("invoice", SearchOptions.CaseInsensitive | SearchOptions.WholeWord);
foreach (var result in searchResults)
{
Console.WriteLine($"Found on page {result.PageIndex} at position {result.Position}: {result.Text}");
// Get surrounding text for context
string context = pdf.ExtractTextFromPage(result.PageIndex)
.Substring(Math.Max(0, result.Position - 50), 100);
Console.WriteLine($"Context: ...{context}...");
}
// Extract tables as structured data
var tables = pdf.ExtractTables();
foreach (var table in tables)
{
for (int row = 0; row < table.RowCount; row++)
{
for (int col = 0; col < table.ColumnCount; col++)
{
Console.Write($"{table[row, col]}\t");
}
Console.WriteLine();
}
}' Advanced PDF analysis with IronPDF
Dim pdf = PdfDocument.FromFile("complex-document.pdf")
' Extract structured content with detailed information
For Each page In pdf.Pages
' Get page dimensions for layout analysis
Dim width = page.Width
Dim height = page.Height
Dim rotation = page.Rotation
' Extract form fields with type information
Dim formFields = page.GetFormFields()
For Each field In formFields
Console.WriteLine($"Field: {field.Name}, Type: {field.Type}, Value: {field.Value}")
Next
' Extract annotations with properties
Dim annotations = page.GetAnnotations()
For Each annotation In annotations
Console.WriteLine($"Annotation: {annotation.Title} - {annotation.Content}")
Next
' Extract hyperlinks with destinations
Dim links = page.GetLinks()
For Each link In links
Console.WriteLine($"Link: {link.Text} -> {link.Url}")
Next
Next
' Advanced search functionality with context
Dim searchResults = pdf.Search("invoice", SearchOptions.CaseInsensitive Or SearchOptions.WholeWord)
For Each result In searchResults
Console.WriteLine($"Found on page {result.PageIndex} at position {result.Position}: {result.Text}")
' Get surrounding text for context
Dim context As String = pdf.ExtractTextFromPage(result.PageIndex).Substring(Math.Max(0, result.Position - 50), 100)
Console.WriteLine($"Context: ...{context}...")
Next
' Extract tables as structured data
Dim tables = pdf.ExtractTables()
For Each table In tables
For row As Integer = 0 To table.RowCount - 1
For col As Integer = 0 To table.ColumnCount - 1
Console.Write($"{table(row, col)}" & vbTab)
Next
Console.WriteLine()
Next
NextEstas características son esenciales para las aplicaciones empresariales que tratan con el procesamiento de formularios o requisitos de cumplimiento. IronPDF admite la conversión PDF/A y los estándares de accesibilidad PDF/UA .
Su decisión entre IronPDF y PDFsharp depende de los requisitos de su proyecto:
Elija IronPDF cuando:
Considere PDFsharp cuando:
IronPDF se destaca en el procesamiento a escala empresarial gracias a su optimización incorporada. La biblioteca admite procesamiento paralelo , operaciones por lotes y transmisión con uso eficiente de la memoria. Los métodos asincrónicos permiten operaciones sin bloqueo en aplicaciones web. El motor Chrome de IronPDF maneja solicitudes simultáneas de manera eficiente, lo que lo hace adecuado para microservicios y funciones sin servidor.
Tanto PDFsharp como IronPDF ofrecen funciones para desarrolladores que buscan soluciones versátiles. PDFsharp proporciona un conjunto de herramientas liviano adecuado para tareas básicas de PDF. Por el contrario, IronPDF está diseñado para operaciones PDF completas. Sus funcionalidades avanzadas lo hacen efectivo para capacidades PDF sofisticadas.
Considere el siguiente ejemplo de código que demuestra la arquitectura limpia de IronPDF:
// IronPDF: Clean, maintainable code following SOLID principles
public class InvoiceService
{
private readonly ITemplateEngine _templateEngine;
private readonly IConfiguration _config;
public async Task<byte[]> GenerateInvoicePdf(Invoice invoice)
{
// Render HTML from template with full CSS support
var html = await _templateEngine.RenderAsync("invoice.html", invoice);
// Configure rendering with fluent API
var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
MarginTop = 50,
MarginBottom = 50,
PaperSize = PdfPaperSize.A4,
Title = $"Invoice #{invoice.Number}",
// Enable JavaScript for dynamic content
EnableJavaScript = true,
// Wait for AJAX calls to complete
WaitFor = WaitFor.NetworkIdle0,
// Custom headers and footers
HtmlHeader = "<div style='text-align: center;'>{page} of {total-pages}</div>",
HtmlFooter = "<div style='text-align: center;'>© 2024 Your Company</div>"
}
};
// Render with full Chrome engine support
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
// Add security features
pdf.SecuritySettings.SetPassword("user-password", "owner-password");
pdf.SecuritySettings.AllowPrinting = true;
pdf.SecuritySettings.AllowCopy = false;
// Add digital signature for authenticity
pdf.SignWithCertificate(certificate, "Authorized Signature");
// Improve for web delivery
pdf.CompressImages(90);
return pdf.BinaryData;
}
}' IronPDF: Clean, maintainable code following SOLID principles
Public Class InvoiceService
Private ReadOnly _templateEngine As ITemplateEngine
Private ReadOnly _config As IConfiguration
Public Async Function GenerateInvoicePdf(invoice As Invoice) As Task(Of Byte())
' Render HTML from template with full CSS support
Dim html = Await _templateEngine.RenderAsync("invoice.html", invoice)
' Configure rendering with fluent API
Dim renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.MarginTop = 50,
.MarginBottom = 50,
.PaperSize = PdfPaperSize.A4,
.Title = $"Invoice #{invoice.Number}",
' Enable JavaScript for dynamic content
.EnableJavaScript = True,
' Wait for AJAX calls to complete
.WaitFor = WaitFor.NetworkIdle0,
' Custom headers and footers
.HtmlHeader = "<div style='text-align: center;'>{page} of {total-pages}</div>",
.HtmlFooter = "<div style='text-align: center;'>© 2024 Your Company</div>"
}
}
' Render with full Chrome engine support
Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
' Add security features
pdf.SecuritySettings.SetPassword("user-password", "owner-password")
pdf.SecuritySettings.AllowPrinting = True
pdf.SecuritySettings.AllowCopy = False
' Add digital signature for authenticity
pdf.SignWithCertificate(certificate, "Authorized Signature")
' Improve for web delivery
pdf.CompressImages(90)
Return pdf.BinaryData
End Function
End ClassEste enfoque proporciona claros beneficios al utilizar conocimientos HTML/CSS existentes y mantener la separación de preocupaciones. La biblioteca gestiona la complejidad para usted a través de su API completa.
Si bien ambas bibliotecas tienen méritos, IronPDF se destaca por sus amplias funciones y simplicidad. Los puntos de referencia de rendimiento muestran que IronPDF maneja documentos grandes de manera eficiente. Para los equipos que priorizan el mantenimiento a largo plazo, IronPDF ofrece documentación completa , soporte profesional y amplios ejemplos de código .
IronPDF es gratuito para uso de desarrollo e incluye una prueba gratuita para la exploración de funciones avanzadas. Para obtener más información sobre cómo visualizar contenido PDF, visita la guía sobre extracción de texto e imágenes . Para obtener ejemplos adicionales, consulte Ejemplos de código HTML a PDF de IronPDF . Su aplicación puede beneficiarse inmediatamente de la arquitectura moderna y las capacidades completas de IronPDF.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
