O IronPDF oferece capacidades completas de visualização de PDFs em C# com sua API intuitiva e conversão de HTML para PDF usando um mecanismo de renderização baseado em Chrome, enquanto o PDFSharp fornece manipulação básica de PDFs de código aberto, exigindo um código significativamente mais complexo para tarefas de extração de texto e visualização.
No desenvolvimento de software, lidar com dados em vários formatos é crucial. O PDF (Portable Document Format) é um padrão amplamente utilizado para o compartilhamento de documentos. Na programação em C#, a visualização de PDFs é essencial para a criação de documentos profissionais e o gerenciamento de conteúdo digital . A biblioteca IronPDF fornece ferramentas completas para geração e manipulação de PDFs .
A versatilidade do C# o torna popular para o desenvolvimento de aplicações em diversos domínios. O formato PDF garante a integridade do documento e uma apresentação consistente em todas as plataformas. Integrar recursos de visualização de PDF em seus aplicativos permite melhorar a experiência do usuário , simplificar fluxos de trabalho e fornecer soluções eficientes para o gerenciamento de documentos. Para aplicações que exigem reconhecimento de texto em documentos digitalizados , soluções OCR complementares podem melhorar suas capacidades de processamento de PDF. A documentação do IronPDF oferece guias de implementação completos. Ao trabalhar com documentos confidenciais , o manuseio correto de PDFs torna-se crucial.
Este artigo explora a visualização de PDFs usando C#, apresenta duas bibliotecas - PDFSharp e IronPDF - e fornece instruções para instalá-las e usá-las. Você analisará as diferenças arquitetônicas, a complexidade do código e as considerações de manutenção que impactam sua escolha entre essas soluções de geração de PDF . Para ambientes que exigem segurança de documentos , compreender essas diferenças é crucial. As demonstrações do IronPDF apresentam implementações do mundo real, enquanto a referência da API fornece especificações detalhadas.
PDFSharp é uma biblioteca de código aberto para C# que oferece aos desenvolvedores um conjunto de ferramentas para manipulação de PDFs. Ao contrário do mecanismo de renderização baseado em Chrome do IronPDF, o PDFSharp opera em um modelo de desenho de baixo nível que oferece controle direto sobre os elementos primitivos do PDF. A biblioteca permite acessar e manipular estruturas de documentos PDF . No entanto, em comparação com os recursos completos do IronPDF, o PDFSharp requer muito mais codificação manual para tarefas comuns.
A arquitetura do PDFSharp segue uma abordagem de modelo de objeto de documento onde você trabalha diretamente com objetos PDF. Isso difere da abordagem de conversão de HTML para PDF do IronPDF , que utiliza tecnologias web para a geração de documentos. Embora o PDFSharp seja excelente na criação de PDFs em branco e operações de desenho, ele requer mais código para tarefas como adicionar cabeçalhos ou incorporar imagens. Recursos avançados, como renderização de JavaScript, suporte a CSS responsivo e integração de fontes da web não estão disponíveis no PDFSharp.
Semelhante ao processo de instalação do IronPDF, o PDFSharp pode ser instalado usando o NuGet. Execute o seguinte comando:
Este comando instala a biblioteca PDFSharp para uso em seu projeto. Ao contrário das opções avançadas de instalação do IronPDF, o PDFSharp não tem suporte embutido para contêineres Docker ou implementações em Linux. O guia de início rápido fornece instruções adicionais de configuração para o IronPDF.
O PDFSharp tem como alvo versões mais antigas do .NET Framework e pode enfrentar problemas de compatibilidade com versões mais recentes do .NET e ambientes em nuvem. A biblioteca requer configuração manual para implantação multiplataforma, diferentemente da detecção automática de plataforma do IronPDF. Os padrões de uso de memória diferem, com o PDFSharp potencialmente consumindo mais recursos para operações complexas. Em cenários de alto desempenho , essas diferenças tornam-se perceptíveis. O guia de desempenho do IronPDF fornece estratégias de otimização indisponíveis no PDFSharp.
A arquitetura de baixo nível do PDFSharp impacta o desempenho através da manipulação direta de objetos PDF, exigindo mais ciclos de CPU. A biblioteca não possui otimização para processamento em lote, operações paralelas ou fluxos de trabalho assíncronos. O desempenho da extração de texto se deteriora com documentos complexos devido à análise manual realizada pelo operador. O mecanismo do IronPDF, baseado no Chrome, utiliza técnicas de otimização do navegador, resultando em renderização mais rápida e melhor eficiência de memória. Para operações assíncronas , a arquitetura do IronPDF oferece vantagens significativas.
IronPDF é uma biblioteca rica em recursos que permite manipular arquivos PDF com facilidade. Projetado com simplicidade e versatilidade, o IronPDF permite criar, editar e ler documentos PDF diretamente em seus aplicativos. Além das funcionalidades básicas, o IronPDF oferece recursos avançados, como conversão de HTML para PDF , suporte a diversos formatos de imagem e gerenciamento eficiente de operações em PDF . A biblioteca se destaca na geração de relatórios em PDF e na conversão de diferentes formatos de arquivo .
A arquitetura do IronPDF utiliza seu mecanismo de renderização Chrome , garantindo a renderização perfeita de conteúdo web em cada pixel. Essa abordagem simplifica tarefas comuns como gerenciar fontes , lidar com JavaScript e dar suporte a caracteres UTF-8 . A biblioteca oferece suporte à linearização , compressão de PDF , assinaturas digitais e anotações .
O IronPDF manipula PDFs e formata dados com suporte para extração de metadados e operações assíncronas . Para aplicações Blazor , o IronPDF oferece integração perfeita.
Instale o IronPDF usando o Gerenciador de Pacotes NuGet ou o Console do Gerenciador de Pacotes:
Este comando instala o IronPDF e suas dependências. Para implementações em Docker ou ambientes Linux , pacotes adicionais podem ser necessários. O guia de início rápido fornece instruções de configuração.
A API do IronPDF segue os padrões modernos do .NET , com interfaces fluentes e suporte assíncrono. A biblioteca fornece nomes de métodos intuitivos e documentação completa IntelliSense. As mensagens de erro fornecem soluções práticas, acelerando o desenvolvimento. A referência da API oferece detalhes completos do método.
Utilize o mecanismo Chrome do IronPDF para converter layouts HTML responsivos, renderizar conteúdo JavaScript ou processar designs CSS modernos. O mecanismo processa fontes da web, gráficos SVG e elementos Canvas automaticamente. É ideal para gerar faturas a partir de modelos HTML ou criar relatórios com visualizações. Para renderizar conteúdo WebGL , o mecanismo oferece aceleração por GPU.
Esta seção demonstra como visualizar arquivos PDF usando PDFSharp. A extração de texto no PDFSharp é complexa devido à sua natureza de baixo nível, ao contrário dos métodos simples do 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 o PDFSharp para ler e extrair texto de um arquivo PDF. O programa abre "output.pdf" em modo de importação e itera pelas páginas para extrair o conteúdo. Ao contrário da API intuitiva do IronPDF , essa abordagem exige a compreensão do funcionamento interno do PDF. Os exemplos de extração de texto do IronPDF demonstram uma abordagem mais simples.
A complexidade do PDFSharp decorre de sua abordagem de baixo nível. Ao contrário da API de alto nível do IronPDF, o PDFSharp requer que você entenda os aspectos internos do PDF, incluindo operadores, codificação e fluxos de conteúdo:
// 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 transformationsEssa diferença arquitetônica impacta significativamente a manutenção. O PDFSharp requer mais código padrão para tarefas comuns como adicionar marcas d'água ou gerenciar orientação de página.
As limitações do PDFSharp tornam-se aparentes ao lidar com requisitos modernos de PDF:
O PDFSharp carrega PDFs inteiros na memória, potencialmente causando problemas com arquivos grandes. O processamento de fluxos de dados não é totalmente suportado, o que limita a escalabilidade. Ao contrário do pipeline de renderização melhorado do IronPDF, o PDFSharp não possui mecanismos de cache incorporados. O guia de otimização de desempenho fornece estratégias indisponíveis no PDFSharp.
Visualizar PDFs com o IronPDF requer apenas algumas linhas de código. A biblioteca gerencia URLs base e codificação de recursos automaticamente:
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 usa o IronPDF para extrair texto de "output.pdf" usando o método ExtractAllText. A implementação lida automaticamente com a complexidade do PDF, fornecendo benefícios claros sobre a análise manual exigida pelo PDFSharp. Sua aplicação pode usar imediatamente esse recurso sem entender os aspectos internos do PDF. O tutorial completo fornece exemplos adicionais.
O IronPDF fornece ferramentas completas para análise de PDFs:
// 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
NextEssas funcionalidades são essenciais para aplicações empresariais que lidam com processamento de formulários ou requisitos de conformidade. O IronPDF oferece suporte à conversão para PDF/A e aos padrões de acessibilidade PDF/UA .
Sua decisão entre o IronPDF e o PDFSharp depende dos requisitos do seu projeto:
Escolha o IronPDF quando: Você precisa de um conversor de HTML para PDF.
Consider PDFSharp when:
O IronPDF se destaca no processamento em escala empresarial graças à otimização integrada. A biblioteca suporta processamento paralelo , operações em lote e streaming com uso eficiente de memória. Os métodos assíncronos permitem operações não bloqueantes em aplicações web. O mecanismo Chrome do IronPDF lida com solicitações simultâneas de forma eficiente, tornando-o adequado para microsserviços e funções sem servidor.
Tanto o PDFSharp quanto o IronPDF oferecem recursos para desenvolvedores que buscam soluções versáteis. O PDFSharp fornece um conjunto de ferramentas leve adequado para tarefas básicas de PDF. Em contrapartida, o IronPDF foi projetado para operações completas com PDFs. Suas funcionalidades avançadas o tornam eficaz para recursos sofisticados de PDF.
Considere o seguinte exemplo de código que demonstra a arquitetura limpa do 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 ClassEssa abordagem oferece benefícios claros ao utilizar habilidades existentes em HTML/CSS e manter a separação de responsabilidades. A biblioteca gerencia a complexidade para você por meio de sua API completa.
Embora ambas as bibliotecas tenham seus méritos, o IronPDF se destaca por seus amplos recursos e simplicidade. Os testes de desempenho mostram que o IronPDF lida com documentos grandes de forma eficiente. Para equipes que priorizam a manutenção a longo prazo, o IronPDF oferece documentação completa , suporte profissional e diversos exemplos de código .
O IronPDF é gratuito para uso em desenvolvimento e inclui um período de avaliação gratuito para exploração de recursos avançados. Para saber mais sobre como visualizar conteúdo de PDFs, consulte o guia sobre como extrair texto e imagens . Para exemplos adicionais, consulte os exemplos de código HTML para PDF do IronPDF . Sua aplicação pode se beneficiar imediatamente da arquitetura moderna e dos recursos completos do IronPDF.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
