O SDK da Biblioteca PDF da Adobe (APDFL) é distribuído pela Datalogics sob licença da Adobe e compartilha o código-fonte central com o motor do Acrobat. É poderoso, mas seu modelo de preço liderado por vendas, pegada de runtime nativa, falta de renderer HTML para PDF embutido e design de API de baixo nível levam muitas equipes .NET a procurarem alternativas. Este guia oferece um caminho de migração passo a passo do SDK da Biblioteca PDF da Adobe para o IronPDF— uma moderna biblioteca PDF .NET que suporta .NET Framework 4.6.2 até .NET 9.
Embora o APDFL ofereça o motor PDF derivado do Acrobat, vários fatores levam as equipes de desenvolvimento a explorar alternativas para HTML-para-PDF, manipulação de documentos e geração de relatórios.
A Datalogics não publica preços de lista para o APDFL. De acordo com as páginas de preços da Datalogics, planos de uso interno começam em cerca de $5,999/ano, e implementações OEM, ISV e SaaS negociam taxas por plataforma, além de royalties ou participação nos rendimentos. O custo total geralmente está fora do alcance para equipes de pequeno a médio porte e quase sempre requer uma conversa de vendas.
APDFL embaça um motor nativo C/C++ que compartilha linhagem com o Acrobat. A vinculação .NET (Datalogics.PDFL) requer binários de tempo de execução específicos para a plataforma — o pacote NuGet Adobe.PDF.Library.LM.NET inclui cargas úteis para Windows x64, Linux e macOS ARM — gerenciamento de memória cuidadoso e um ciclo de vida explícito Library em cada ponto de entrada. Isso adiciona sobrecarga ao desenvolvimento e complica pipelines CI/CD.
A lista de conversão documentada do APDFL abrange PDF/A, PDF/X, ZUGFeRD, EPS, PS, XPS e formatos Office, mas não HTML. Produzir um PDF a partir de uma string HTML apenas com o APDFL significa construir manualmente páginas, fontes e execuções de conteúdo, ou emparelhar o APDFL com um motor de renderização HTML separado.
Criar PDFs com APDFL envolve construir páginas, fluxos de conteúdo, execuções de texto e fontes programaticamente. Tarefas simples, como renderizar uma string HTML, tornam-se operações multi-etapas envolvendo cálculos de coordenadas, incorporação de fontes e gerenciamento manual de elementos de conteúdo.
Cada ponto de entrada requer envolver o código em using (var lib = new Library()) (ou chamadas emparelhadas Library.Initialize() / Library.Terminate()) com descarte cuidadoso de cada objeto PDF criado dentro. Limpeza perdida pode produzir vazamentos de recursos.
Para aplicações que precisam principalmente de conversão HTML para PDF, manipulação básica de documentos ou geração de relatórios, o motor derivado do Acrobat é frequentemente mais do que a carga de trabalho requer.
Compreender as diferenças arquitetônicas fundamentais entre essas bibliotecas ajuda a planejar uma estratégia de migração eficaz.
| Aspecto | SDK da Biblioteca PDF da Adobe | IronPDF |
|---|---|---|
| Preços | Liderado por vendas; uso interno a partir de ~$5,999/ano, royalties OEM/SaaS adicionais | Transparente por desenvolvedor / por implantação |
| Instalação | Adobe.PDF.Library.LM.NET distribui tempos de execução nativos por plataforma | Pacote NuGet simples |
| Criação de Documentos | Construção de páginas/conteúdo de baixo nível | Renderização HTML/CSS |
| HTML para PDF | Não embutido | ChromePdfRenderer.RenderHtmlAsPdf |
| Inicialização | using (Library lib = new Library()) necessário | Automático |
| Sistema de coordenadas | Pontos PostScript, origem no canto inferior esquerdo | Layout baseado em CSS |
| Manipulação de fontes | Incorporação manual necessária | Automático |
| Gerenciamento de memória | Descarte manual de cada objeto PDF | Padrão IDisposable |
| Suporte assíncrono | Não disponível | Suporte completo a async/await |
Certifique-se de que seu ambiente atenda a esses requisitos antes de iniciar a migração:
Execute estes comandos no diretório da sua solução para identificar todas as referências ao SDK da Biblioteca PDF da Adobe:
grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .| Categoria | SDK da Biblioteca PDF da Adobe | IronPDF | Ação contra a migração |
|---|---|---|---|
| Inicialização | Library.Initialize() / Terminate() | Automático | Remover código de ciclo de vida |
| Criação de Documentos | new Document() com construção de página | ChromePdfRenderer | Usar renderização HTML |
| Sistema de coordenadas | Pontos PostScript, origem no canto inferior esquerdo | Layout baseado em CSS | Use HTML/CSS |
| Manipulação de fontes | Criação e incorporação manual Font | Automático | Remover código de fonte |
| Gerenciamento de memória | Eliminação manual de objetos COM | Padrão IDescartável | Use declarações using |
| Construção da página | CreatePage(), AddContent() | Automático a partir de HTML | Simplificar significativamente |
Remova o pacote do SDK da biblioteca Adobe PDF e instale o IronPDF:
# Remove Adobe PDF Library (.NET 6/7/8 projects)
dotnet remove package Adobe.PDF.Library.LM.NET
# .NET Framework projects use the LM.NETFramework variant
dotnet remove package Adobe.PDF.Library.LM.NETFramework
# Install IronPDF
dotnet add package IronPdfSubstitua o licenciamento da Adobe pela chave de licença baseada em código do IronPDF:
// Replace Adobe's Library.LicenseKey with IronPDF license
// Add at application startup, before any IronPDF operations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;' Replace Adobe's Library.LicenseKey with IronPDF license
' Add at application startup, before any IronPDF operations
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' Verify license status
Dim isLicensed As Boolean = IronPdf.License.IsLicensedExecute uma operação global de localizar e substituir em toda a sua solução:
| Encontrar | Substitua por |
|---|---|
using Datalogics.PDFL; | using IronPdf; |
APDFL expõe um único namespace raiz, Datalogics.PDFL. Document, Page, Content, Font e Color são todas classes dentro desse namespace, então há apenas uma diretiva using para trocar.
Uma das simplificações mais significativas envolve a remoção dos padrões de inicialização e término:
// SDK da Biblioteca PDF da Adobe - REMOVE THIS PATTERN
Library.Initialize();
try
{
// PDF operations
}
finally
{
Library.Terminate(); // Must always terminate
}
//IronPDF- Just use directly
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);| Método Adobe | Equivalente ao IronPDF |
|---|---|
Library.Initialize() | Não é necessário |
Library.Terminate() | Não é necessário |
Library.LicenseKey = "KEY" | IronPdf.License.LicenseKey = "KEY" |
using (Library lib = new Library()) | Não é necessário |
| Método Adobe | Método IronPDF |
|---|---|
new Document() | new ChromePdfRenderer() |
new Document(path) | PdfDocument.FromFile(path) |
doc.CreatePage(index, rect) | Automático a partir de HTML |
doc.Save(SaveFlags.Full, path) | pdf.SaveAs(path) |
doc.NumPages | pdf.PageCount |
doc.GetPage(index) | pdf.Pages[index] |
doc.InsertPages(insertAfter, src, start, count, flags) | PdfDocument.Merge(pdfs) |
O SDK da Biblioteca PDF da Adobe requer a construção de conteúdo em baixo nível. O IronPDF utiliza HTML/CSS:
| Método Adobe | Método IronPDF |
|---|---|
new Text() | Use HTML <p>, <h1>, etc. |
text.AddRun(textRun) | Use HTML |
new TextRun(text, font, size, point) | Estilização CSS |
new Font(name, flags) | CSS font-family |
new Image(path) | Tag HTML <img> |
content.AddElement(...) | Conteúdo HTML |
page.UpdateContent() | Não é necessário |
| Método Adobe | Método IronPDF |
|---|---|
doc.Watermark(textParams, wmParams) | pdf.ApplyWatermark(html) |
WatermarkParams.Opacity (0.0-1.0) | Parâmetro opacity (0-100) ou CSS opacity |
new EncryptionHandler(user, owner, perms) | pdf.SecuritySettings |
PermissionFlags.PrintDoc | AllowUserPrinting |
| Método Adobe | Método IronPDF |
|---|---|
new WordFinder(doc, config) | pdf.ExtractAllText() |
wordFinder.GetWordList() | pdf.Pages[i].Text |
| iteração complexa de palavras/caracteres | Chamada de método único |
APDFL não tem um renderizador HTML embutido. O mais próximo semelhante é construir páginas e execuções de conteúdo manualmente para imitar o layout que um documento HTML produziria — ou emparelhar o APDFL com um motor de HTML para PDF separado.
Implementação do SDK da Biblioteca PDF da Adobe:
// SDK da Biblioteca PDF da Adobe (Datalogics APDFL)
// NuGet: Adobe.PDF.Library.LM.NET — namespace Datalogics.PDFL
using Datalogics.PDFL;
using System;
class AdobeHtmlToPdf
{
static void Main()
{
using (Library lib = new Library())
using (Document doc = new Document())
{
// US Letter in points (8.5 x 11 inches @ 72 DPI)
Rect pageRect = new Rect(0, 0, 612, 792);
using (Page page = doc.CreatePage(Document.BeforeFirstPage, pageRect))
{
Content content = page.Content;
Font font = new Font("Helvetica", FontCreateFlags.Embedded);
Text text = new Text();
text.AddRun(new TextRun("Hello World", font, 24, new Point(72, 720)));
content.AddElement(text);
page.UpdateContent();
}
doc.Save(SaveFlags.Full, "output.pdf");
}
}
}Implementação do IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class IronPdfHtmlToPdf
{
static void Main()
{
var renderer = new ChromePdfRenderer();
string htmlContent = "<html><body><h1>Hello World</h1></body></html>";
// Convert HTML to PDF with simple API
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System
Class IronPdfHtmlToPdf
Shared Sub Main()
Dim renderer As New ChromePdfRenderer()
Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
' Convert HTML to PDF with simple API
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")
End Sub
End ClassO IronPDF elimina o encapsulamento do ciclo de vida da biblioteca, os objetos de parâmetros de conversão e o descarte explícito. O ChromePdfRenderer usa um mecanismo baseado em Chromium para suporte a CSS e JavaScript pixel-perfect. Para cenários avançados, consulte a documentação de conversão de HTML para PDF .
A fusão de PDFs demonstra claramente a diferença na complexidade da API.
Implementação do SDK da Biblioteca PDF da Adobe:
// SDK da Biblioteca PDF da Adobe (Datalogics APDFL)
using Datalogics.PDFL;
using System;
class AdobeMergePdfs
{
static void Main()
{
using (Library lib = new Library())
using (Document doc1 = new Document("document1.pdf"))
using (Document doc2 = new Document("document2.pdf"))
{
// InsertPages(insertAfter, sourceDoc, sourceStartPage, pageCount, flags)
doc1.InsertPages(
Document.LastPage,
doc2,
0,
Document.AllPages,
PageInsertFlags.Bookmarks | PageInsertFlags.Threads);
doc1.Save(SaveFlags.Full, "merged.pdf");
}
}
}Implementação do IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class IronPdfMergePdfs
{
static void Main()
{
// Load PDF documents
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
// Merge PDFs with simple method
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System
Class IronPdfMergePdfs
Shared Sub Main()
' Load PDF documents
Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
' Merge PDFs with simple method
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")
End Sub
End ClassA abordagem da Adobe exige iteração página por página com parâmetros de inserção.IronPDF fornece um único método Merge que aceita vários documentos.
A aplicação de marcas d'água ilustra como o IronPDF utiliza HTML/CSS para oferecer flexibilidade de estilo.
Implementação do SDK da Biblioteca PDF da Adobe:
// SDK da Biblioteca PDF da Adobe (Datalogics APDFL)
using Datalogics.PDFL;
using System;
class AdobeAddWatermark
{
static void Main()
{
using (Library lib = new Library())
using (Document doc = new Document("input.pdf"))
{
WatermarkParams watermarkParams = new WatermarkParams();
watermarkParams.Opacity = 0.5; // 0.0 - 1.0
watermarkParams.Rotation = 45.0;
watermarkParams.Scale = -1; // auto-fit
WatermarkTextParams textParams = new WatermarkTextParams();
textParams.Text = "CONFIDENTIAL";
textParams.Color = new Color(0.8, 0.8, 0.8);
textParams.TextAlign = HorizontalAlignment.Center;
// Apply via Document.Watermark(textParams, wmParams)
doc.Watermark(textParams, watermarkParams);
doc.Save(SaveFlags.Full, "watermarked.pdf");
}
}
}Implementação do IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;
class IronPdfAddWatermark
{
static void Main()
{
var pdf = PdfDocument.FromFile("input.pdf");
// Apply text watermark with simple API
pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
rotation: 45,
verticalAlignment: VerticalAlignment.Middle,
horizontalAlignment: HorizontalAlignment.Center);
pdf.SaveAs("watermarked.pdf");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Editing
Imports System
Class IronPdfAddWatermark
Shared Sub Main()
Dim pdf = PdfDocument.FromFile("input.pdf")
' Apply text watermark with simple API
pdf.ApplyWatermark("<h1 style='color:red; opacity:0.5;'>CONFIDENTIAL</h1>",
rotation:=45,
verticalAlignment:=VerticalAlignment.Middle,
horizontalAlignment:=HorizontalAlignment.Center)
pdf.SaveAs("watermarked.pdf")
End Sub
End ClassA marca d'água baseada em HTML do IronPDF oferece controle total do design por meio de estilos CSS, eliminando a necessidade de objetos de parâmetros separados.
Implementação do SDK da Biblioteca PDF da Adobe:
using Datalogics.PDFL;
public void ProtectPdf(string inputPath, string outputPath, string password)
{
Library.Initialize();
try
{
using (Document doc = new Document(inputPath))
{
PermissionFlags permissions =
PermissionFlags.PrintDoc |
PermissionFlags.PrintFidelity;
EncryptionHandler encHandler = new EncryptionHandler(
password, // User password
password, // Owner password
permissions,
EncryptionMethod.AES256);
doc.SetEncryptionHandler(encHandler);
doc.Save(SaveFlags.Full | SaveFlags.Encrypted, outputPath);
}
}
finally
{
Library.Terminate();
}
}Imports Datalogics.PDFL
Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
Library.Initialize()
Try
Using doc As New Document(inputPath)
Dim permissions As PermissionFlags = PermissionFlags.PrintDoc Or PermissionFlags.PrintFidelity
Dim encHandler As New EncryptionHandler(
password, ' User password
password, ' Owner password
permissions,
EncryptionMethod.AES256)
doc.SetEncryptionHandler(encHandler)
doc.Save(SaveFlags.Full Or SaveFlags.Encrypted, outputPath)
End Using
Finally
Library.Terminate()
End Try
End SubImplementação do IronPDF:
using IronPdf;
public void ProtectPdf(string inputPath, string outputPath, string password)
{
using var pdf = PdfDocument.FromFile(inputPath);
pdf.SecuritySettings.UserPassword = password;
pdf.SecuritySettings.OwnerPassword = password;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;
pdf.SaveAs(outputPath);
}Imports IronPdf
Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
Using pdf = PdfDocument.FromFile(inputPath)
pdf.SecuritySettings.UserPassword = password
pdf.SecuritySettings.OwnerPassword = password
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit
pdf.SaveAs(outputPath)
End Using
End SubO IronPDF usa propriedades fortemente tipadas em vez de sinalizadores de permissão bit a bit e objetos manipuladores de criptografia.
Implementação do SDK da Biblioteca PDF da Adobe:
using Datalogics.PDFL;
public string ExtractText(string pdfPath)
{
string extractedText = "";
Library.Initialize();
try
{
using (Document doc = new Document(pdfPath))
{
WordFinderConfig config = new WordFinderConfig();
config.IgnoreCharGaps = true;
for (int i = 0; i < doc.NumPages; i++)
{
using (WordFinder wordFinder = new WordFinder(doc, i, config))
{
IList<Word> words = wordFinder.GetWordList();
foreach (Word word in words)
{
extractedText += word.Text + " ";
}
extractedText += "\n";
}
}
}
}
finally
{
Library.Terminate();
}
return extractedText;
}Imports Datalogics.PDFL
Public Function ExtractText(ByVal pdfPath As String) As String
Dim extractedText As String = ""
Library.Initialize()
Try
Using doc As New Document(pdfPath)
Dim config As New WordFinderConfig()
config.IgnoreCharGaps = True
For i As Integer = 0 To doc.NumPages - 1
Using wordFinder As New WordFinder(doc, i, config)
Dim words As IList(Of Word) = wordFinder.GetWordList()
For Each word As Word In words
extractedText &= word.Text & " "
Next
extractedText &= vbLf
End Using
Next
End Using
Finally
Library.Terminate()
End Try
Return extractedText
End FunctionImplementação do IronPDF:
using IronPdf;
public string ExtractText(string pdfPath)
{
using var pdf = PdfDocument.FromFile(pdfPath);
return pdf.ExtractAllText();
}Imports IronPdf
Public Function ExtractText(pdfPath As String) As String
Using pdf = PdfDocument.FromFile(pdfPath)
Return pdf.ExtractAllText()
End Using
End FunctionA iteração palavra por palavra da Adobe se torna uma chamada de método única com o IronPDF.
Implementação do SDK da Biblioteca PDF da Adobe:
using Datalogics.PDFL;
public void AddHeaderFooter(string inputPath, string outputPath)
{
Library.Initialize();
try
{
using (Document doc = new Document(inputPath))
{
Font font = new Font("Helvetica", FontCreateFlags.None);
for (int i = 0; i < doc.NumPages; i++)
{
using (Page page = doc.GetPage(i))
{
Content content = page.Content;
// Add header
Text header = new Text();
header.AddRun(new TextRun("Document Header",
font, 10, new Point(72, page.MediaBox.Top - 36)));
content.AddElement(header);
// Add footer with page number
Text footer = new Text();
footer.AddRun(new TextRun($"Page {i + 1} of {doc.NumPages}",
font, 10, new Point(72, 36)));
content.AddElement(footer);
page.UpdateContent();
}
}
doc.Save(SaveFlags.Full, outputPath);
}
}
finally
{
Library.Terminate();
}
}Imports Datalogics.PDFL
Public Sub AddHeaderFooter(inputPath As String, outputPath As String)
Library.Initialize()
Try
Using doc As New Document(inputPath)
Dim font As New Font("Helvetica", FontCreateFlags.None)
For i As Integer = 0 To doc.NumPages - 1
Using page As Page = doc.GetPage(i)
Dim content As Content = page.Content
' Add header
Dim header As New Text()
header.AddRun(New TextRun("Document Header", font, 10, New Point(72, page.MediaBox.Top - 36)))
content.AddElement(header)
' Add footer with page number
Dim footer As New Text()
footer.AddRun(New TextRun($"Page {i + 1} of {doc.NumPages}", font, 10, New Point(72, 36)))
content.AddElement(footer)
page.UpdateContent()
End Using
Next
doc.Save(SaveFlags.Full, outputPath)
End Using
Finally
Library.Terminate()
End Try
End SubImplementação do IronPDF:
using IronPdf;
public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
CenterText = "Document Header",
FontSize = 10,
FontFamily = "Helvetica"
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
CenterText = "Page {page} of {total-pages}",
FontSize = 10,
FontFamily = "Helvetica"
};
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);
}Imports IronPdf
Public Sub CreatePdfWithHeaderFooter(html As String, outputPath As String)
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
.CenterText = "Document Header",
.FontSize = 10,
.FontFamily = "Helvetica"
}
renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
.CenterText = "Page {page} of {total-pages}",
.FontSize = 10,
.FontFamily = "Helvetica"
}
Using pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(outputPath)
End Using
End SubIronPDF trata a iteração de páginas automaticamente e suporta tokens substitutos como {page} e {total-pages}. Para layouts mais avançados, consulte a documentação de cabeçalhos e rodapés .
O SDK da Biblioteca PDF da Adobe não possui um recurso integrado de renderização de URLs. O IronPDF oferece suporte nativo:
using IronPdf;
public void ConvertUrlToPdf(string url, string outputPath)
{
var renderer = new ChromePdfRenderer();
using var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs(outputPath);
}Imports IronPdf
Public Sub ConvertUrlToPdf(url As String, outputPath As String)
Dim renderer As New ChromePdfRenderer()
Using pdf = renderer.RenderUrlAsPdf(url)
pdf.SaveAs(outputPath)
End Using
End SubPara obter informações completas sobre as opções de conversão de URL, consulte a documentação de URL para PDF .
O padrão de inicialização estática do SDK da Biblioteca PDF da Adobe cria atrito com a injeção de dependência. O IronPDF integra-se naturalmente com as arquiteturas .NET modernas.
Padrão Adobe (problemático para DI):
public class AdobePdfService
{
public byte[] Generate(string content)
{
Library.Initialize();
try
{
// Documento complexo construction...
return bytes;
}
finally
{
Library.Terminate();
}
}
}Public Class AdobePdfService
Public Function Generate(content As String) As Byte()
Library.Initialize()
Try
' Documento complexo construction...
Return bytes
Finally
Library.Terminate()
End Try
End Function
End ClassPadrão IronPDF(Compatível com DI):
public interface IPdfService
{
Task<byte[]> GeneratePdfAsync(string html);
}
public class IronPdfService : IPdfService
{
private readonly ChromePdfRenderer _renderer;
public IronPdfService()
{
_renderer = new ChromePdfRenderer();
_renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
}
public async Task<byte[]> GeneratePdfAsync(string html)
{
using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
return pdf.BinaryData;
}
}
// Register in Program.cs (.NET 6+):
builder.Services.AddSingleton<IPdfService, IronPdfService>();Imports System.Threading.Tasks
Public Interface IPdfService
Function GeneratePdfAsync(html As String) As Task(Of Byte())
End Interface
Public Class IronPdfService
Implements IPdfService
Private ReadOnly _renderer As ChromePdfRenderer
Public Sub New()
_renderer = New ChromePdfRenderer()
_renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
End Sub
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte()) Implements IPdfService.GeneratePdfAsync
Using pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
Return pdf.BinaryData
End Using
End Function
End Class
' Register in Program.vb (.NET 6+):
builder.Services.AddSingleton(Of IPdfService, IronPdfService)()O SDK da Biblioteca de PDF da Adobe não oferece suporte a operações assíncronas. O IronPDF oferece recursos completos de async/await, essenciais para aplicações web escaláveis:
public async Task<IActionResult> GenerateReport()
{
var renderer = new ChromePdfRenderer();
using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
return File(pdf.BinaryData, "application/pdf");
}Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Public Class ReportController
Inherits Controller
Public Async Function GenerateReport() As Task(Of IActionResult)
Dim renderer As New ChromePdfRenderer()
Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
Return File(pdf.BinaryData, "application/pdf")
End Using
End Function
End Class| Cenário | SDK da Biblioteca PDF da Adobe | IronPDF |
|---|---|---|
| PDF simples | ~100 MB | ~50 MB |
| Documento complexo | ~200 MB | ~80 MB |
| Lote (100 PDFs) | Alta (memória nativa) | ~100 MB |
Reutilizar instâncias do renderizador:
// Good: Reuse renderer for batch operations
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs($"output_{i}.pdf");
}' Good: Reuse renderer for batch operations
Dim renderer = New ChromePdfRenderer()
For Each html In htmlList
Using pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs($"output_{i}.pdf")
End Using
NextUtilizando Async em Aplicações Web:
public async Task<IActionResult> GenerateReport()
{
var renderer = new ChromePdfRenderer();
using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
return File(pdf.BinaryData, "application/pdf");
}Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Public Class ReportController
Inherits Controller
Public Async Function GenerateReport() As Task(Of IActionResult)
Dim renderer As New ChromePdfRenderer()
Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
Return File(pdf.BinaryData, "application/pdf")
End Using
End Function
End ClassA Adobe utiliza coordenadas de ponto PostScript. O IronPDF utiliza posicionamento CSS:
// Adobe: Point-based
new TextRun("Hello", font, 12, new Point(100, 700));
// IronPDF: CSS-based
string html = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>";' Adobe: Point-based
New TextRun("Hello", font, 12, New Point(100, 700))
' IronPDF: CSS-based
Dim html As String = "<p style='position:absolute; left:100px; top:92px;'>Hello</p>"A Adobe utiliza pontos PostScript. O IronPDF usa enumerações ou dimensões personalizadas:
// Adobe: Points
Rect(0, 0, 612, 792) // Letter
// IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);' Adobe: Points
Rect(0, 0, 612, 792) ' Letter
' IronPDF: Enum or custom
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
' Or custom:
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11)A Adobe exige a incorporação manual de fontes. O IronPDF lida com fontes automaticamente:
// IronPDF: Use web fonts if needed
string html = @"
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
body { font-family: 'Roboto', sans-serif; }
</style>";' IronPDF: Use web fonts if needed
Dim html As String = "
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
body { font-family: 'Roboto', sans-serif; }
</style>"A Adobe usa combinações de sinalizadores de salvamento. O IronPDF usa o recurso de salvamento direto:
// Adobe
doc.Save(SaveFlags.Full | SaveFlags.Incremental, path);
//IronPDF- full save is default
pdf.SaveAs(path);netApós concluir a migração do código, verifique o seguinte:
IronPdf.License.IsLicensed)Migrar do APDFL para o IronPDF pode simplificar a base de código típica de geração PDF .NET, particularmente para equipes cuja necessidade principal é HTML para PDF ou manipulação de documentos em vez de toda a superfície de recursos derivada do Acrobat. A mudança da construção de página de baixo nível para renderização HTML/CSS remove a maior parte do cálculo de coordenadas, gerenciamento de fontes e código de manipulação do ciclo de vida Library, e o licenciamento transparente por desenvolvedor do IronPDF geralmente é mais fácil de orçar do que o modelo de vendas, OEM/SaaS-royalty do APDFL.
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.
