GUIAS DE MIGRAçãO

Como migrar do SDK da Biblioteca de PDF da Adobe para o IronPDF

Atualizado:maio 18, 2026

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.

Por que considerar migrar do SDK da Biblioteca de PDF da Adobe?

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.

Preços Sob Medida e Liderados por Vendas

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.

Integração complexa de SDK nativo

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.

Renderer HTML Inexistente

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.

Design de API de baixo nível

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.

Custos indiretos da gestão do ciclo de vida da biblioteca

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.

Demais para Muitos Projetos

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.

SDK da Biblioteca PDF da Adobe vs. IronPDF: Principais Diferenças

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

Preparação pré-migratória

Pré-requisitos

Certifique-se de que seu ambiente atenda a esses requisitos antes de iniciar a migração:

.NET Framework 4.6.2 ou superior ou .NET Core 3.1 / .NET 5-9
Visual Studio 2019 ou superior ou JetBrains Rider
Acesso ao Gerenciador de Pacotes NuGet
Chave de licença do IronPDF(teste gratuito disponível em IronPDF )

Auditoria de uso do SDK da Biblioteca Adobe PDF

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" .

grep -r "using Datalogics" --include="*.cs" .
grep -r "Adobe.PDF.Library" --include="*.csproj" .
grep -r "Library.Initialize\|Library.Terminate" --include="*.cs" .

SHELL

Mudanças significativas a serem previstas

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

Processo de migração passo a passo

Passo 1: Atualizar pacotes NuGet

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 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 IronPdf

SHELL

Etapa 2: Configurar a chave de licença

Substitua 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
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.IsLicensed

$vbLabelText $csharpLabel

Etapa 3: Atualizar referências de namespace

Execute 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.

Etapa 4: Remover o código do ciclo de vida da biblioteca

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);

// 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);

' SDK da Biblioteca PDF da Adobe - REMOVE THIS PATTERN
Library.Initialize()
Try
    ' PDF operations
Finally
    Library.Terminate() ' Must always terminate
End Try

' IronPDF- Just use directly
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

$vbLabelText $csharpLabel

Referência completa para migração de API

Métodos do ciclo de vida da biblioteca

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étodos de Criação de Documentos

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)`

Criação de Conteúdo (Grande Mudança de Paradigma)

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

Marca d'água e métodos de segurança

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`

Extração de texto

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

Exemplos de migração de código

Conversão de HTML para PDF

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");
        }
    }
}

// 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");
        }
    }
}

Imports Datalogics.PDFL
Imports System

Class AdobeHtmlToPdf
    Shared Sub Main()
        Using lib As New Library()
            Using doc As New Document()
                ' US Letter in points (8.5 x 11 inches @ 72 DPI)
                Dim pageRect As New Rect(0, 0, 612, 792)
                Using page As Page = doc.CreatePage(Document.BeforeFirstPage, pageRect)
                    Dim content As Content = page.Content
                    Dim font As New Font("Helvetica", FontCreateFlags.Embedded)

                    Dim text As New Text()
                    text.AddRun(New TextRun("Hello World", font, 24, New Point(72, 720)))
                    content.AddElement(text)

                    page.UpdateContent()
                End Using

                doc.Save(SaveFlags.Full, "output.pdf")
            End Using
        End Using
    End Sub
End Class

$vbLabelText $csharpLabel

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
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");
    }
}

Imports IronPdf
Imports System

Class IronPdfHtmlToPdf
    Shared Sub Main()
        Dim renderer = 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 Class

$vbLabelText $csharpLabel

O 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 .

Unir vários PDFs

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");
        }
    }
}

// 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");
        }
    }
}

Imports Datalogics.PDFL
Imports System

Class AdobeMergePdfs
    Shared Sub Main()
        Using lib As New Library()
            Using doc1 As New Document("document1.pdf")
                Using doc2 As New Document("document2.pdf")
                    ' InsertPages(insertAfter, sourceDoc, sourceStartPage, pageCount, flags)
                    doc1.InsertPages(Document.LastPage, doc2, 0, Document.AllPages, PageInsertFlags.Bookmarks Or PageInsertFlags.Threads)

                    doc1.Save(SaveFlags.Full, "merged.pdf")
                End Using
            End Using
        End Using
    End Sub
End Class

$vbLabelText $csharpLabel

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
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");
    }
}

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 Class

$vbLabelText $csharpLabel

A 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.

Adicionando marcas d'água

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");
        }
    }
}

// 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");
        }
    }
}

Imports Datalogics.PDFL
Imports System

Class AdobeAddWatermark
    Shared Sub Main()
        Using lib As New Library()
            Using doc As New Document("input.pdf")
                Dim watermarkParams As New WatermarkParams()
                watermarkParams.Opacity = 0.5 ' 0.0 - 1.0
                watermarkParams.Rotation = 45.0
                watermarkParams.Scale = -1 ' auto-fit

                Dim textParams As 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")
            End Using
        End Using
    End Sub
End Class

$vbLabelText $csharpLabel

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
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");
    }
}

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 Class

$vbLabelText $csharpLabel

A 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.

Proteção por senha e criptografia

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();
    }
}

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 Sub

$vbLabelText $csharpLabel

Implementaçã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);
}

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 Sub

$vbLabelText $csharpLabel

O IronPDF usa propriedades fortemente tipadas em vez de sinalizadores de permissão bit a bit e objetos manipuladores de criptografia.

Extração de texto

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;
}

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 Function

$vbLabelText $csharpLabel

Implementação do IronPDF:

using IronPdf;

public string ExtractText(string pdfPath)
{
    using var pdf = PdfDocument.FromFile(pdfPath);
    return pdf.ExtractAllText();
}

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 Function

$vbLabelText $csharpLabel

A iteração palavra por palavra da Adobe se torna uma chamada de método única com o IronPDF.

Cabeçalhos e rodapés

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();
    }
}

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 Sub

$vbLabelText $csharpLabel

Implementaçã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);
}

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 Sub

$vbLabelText $csharpLabel

IronPDF 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 .

Conversão de URL para PDF

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);
}

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 Sub

$vbLabelText $csharpLabel

Para obter informações completas sobre as opções de conversão de URL, consulte a documentação de URL para PDF .

Integração com ASP.NET Core

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 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 Class

$vbLabelText $csharpLabel

Padrã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>();

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)()

$vbLabelText $csharpLabel

Suporte assíncrono

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");
}

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

$vbLabelText $csharpLabel

Otimização de desempenho

Comparação de uso de memória

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

Dicas de otimização

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
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
Next

$vbLabelText $csharpLabel

Utilizando 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");
}

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

$vbLabelText $csharpLabel

Solução de problemas comuns de migração

Problema: Posicionamento baseado em coordenadas não está funcionando

A 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
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>"

$vbLabelText $csharpLabel

Problema: Diferenças no tamanho das páginas

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);

' 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)

$vbLabelText $csharpLabel

Problema: Fonte não encontrada

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
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>"

$vbLabelText $csharpLabel

Problema: SaveFlags não disponível

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);

// Adobe
doc.Save(SaveFlags.Full | SaveFlags.Incremental, path);

//IronPDF- full save is default
pdf.SaveAs(path);

$vbLabelText $csharpLabel

Lista de verificação pós-migração

Após concluir a migração do código, verifique o seguinte:

Executar todos os testes de unidade e integração existentes
Compare visualmente as saídas em PDF com as versões anteriores.
Teste todos os fluxos de trabalho de PDF em um ambiente de teste.
Verifique se o licenciamento funciona corretamente (IronPdf.License.IsLicensed)
Comparação de desempenho com a implementação anterior.
Remover configuração de licenciamento da Adobe
Atualizar dependências do pipeline CI/CD
Remova todas as DLLs da Biblioteca Adobe PDF do projeto.
Documente novos padrões para sua equipe de desenvolvimento.

Recursos adicionais

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.

ObserveAdobe, Acrobat e Adobe PDF Library são marcas registradas da Adobe Inc. APDFL é distribuído pela Datalogics, Inc. sob licença da Adobe. Este site não é afiliado, endossado ou patrocinado por Adobe Inc. ou Datalogics, Inc. Todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos proprietários. As comparações são apenas para fins informativos e refletem informações disponíveis publicamente no momento da redação.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

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 ...

Experimente gratuitamente por 30 dias.

Como migrar do SDK da Biblioteca de PDF da Adobe para o IronPDF

Por que considerar migrar do SDK da Biblioteca de PDF da Adobe?

Preços Sob Medida e Liderados por Vendas

Integração complexa de SDK nativo

Renderer HTML Inexistente

Design de API de baixo nível

Custos indiretos da gestão do ciclo de vida da biblioteca

Demais para Muitos Projetos

SDK da Biblioteca PDF da Adobe vs. IronPDF: Principais Diferenças

Preparação pré-migratória

Pré-requisitos

Auditoria de uso do SDK da Biblioteca Adobe PDF

Mudanças significativas a serem previstas

Processo de migração passo a passo

Passo 1: Atualizar pacotes NuGet

Etapa 2: Configurar a chave de licença

Etapa 3: Atualizar referências de namespace

Etapa 4: Remover o código do ciclo de vida da biblioteca

Referência completa para migração de API

Métodos do ciclo de vida da biblioteca

Métodos de Criação de Documentos

Criação de Conteúdo (Grande Mudança de Paradigma)

Marca d'água e métodos de segurança

Extração de texto

Exemplos de migração de código

Conversão de HTML para PDF

Unir vários PDFs

Adicionando marcas d'água

Proteção por senha e criptografia

Extração de texto

Cabeçalhos e rodapés

Conversão de URL para PDF

Integração com ASP.NET Core

Suporte assíncrono

Otimização de desempenho

Comparação de uso de memória

Dicas de otimização

Solução de problemas comuns de migração

Problema: Posicionamento baseado em coordenadas não está funcionando

Problema: Diferenças no tamanho das páginas

Problema: Fonte não encontrada

Problema: SaveFlags não disponível

Lista de verificação pós-migração

Recursos adicionais

Artigos relacionados

Como migrar do ZetPDF para o IronPDF em C#

Como migrar do Scryber.Core para o IronPDF em C#

Como migrar do XFINIUM.PDF para o IronPDF em C#

Próximo passo: Inicie o teste gratuito de 30 dias.

Thank You

Próximo passo: Inicie o teste gratuito de 30 dias.

Quer implantar o IronSuite em um projeto real de graça?

O que está incluído?

Sua chave de licença foi entregue à sua caixa de entrada

Sua solicitação de demonstração está em andamento.

Aprovado por milhões de engenheiros em todo o mundo.

Equipe de Suporte Iron