GUIAS DE MIGRAçãO

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

Atualizado:fevereiro 1, 2026

O SDK da Biblioteca PDF da Adobe, disponibilizado pela Datalogics, fornece ao mecanismo PDF autêntico da Adobe recursos de alto nível. No entanto, os altos custos de licenciamento, a complexa integração com o SDK nativo e o design de API de baixo nível tornam essa solução impraticável para muitas equipes de desenvolvimento. Este guia oferece um caminho de migração passo a passo do SDK da Biblioteca PDF da Adobe para o IronPDF— uma biblioteca PDF .NET moderna e econômica, compatível com o .NET Framework 4.6.2 até o .NET 9 e versões futuras.

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

Embora o SDK da Biblioteca PDF da Adobe ofereça o mecanismo PDF genuíno da Adobe, diversos fatores levam as equipes de desenvolvimento a explorar alternativas para suas necessidades de geração e manipulação de PDFs.

Altos custos de licenciamento

O SDK da Biblioteca de PDF da Adobe opera em níveis de preços corporativos, normalmente variando de US$ 10.000 a mais de US$ 50.000 por ano. Essa estrutura de custos torna o SDK impraticável para pequenas e médias empresas, startups, desenvolvedores individuais e projetos onde os recursos completos do mecanismo da Adobe não são essenciais.

Integração complexa de SDK nativo

O SDK da Biblioteca PDF da Adobe é construído em código C++ nativo, exigindo binários específicos da plataforma. Os desenvolvedores devem gerenciar a memória com cuidado, lidar com padrões explícitos de inicialização e término e executar procedimentos de configuração complexos. Isso aumenta significativamente a sobrecarga de desenvolvimento e complica os fluxos de trabalho de CI/CD.

Design de API de baixo nível

A criação de PDFs com o SDK da Biblioteca de PDF da Adobe envolve a construção programática de páginas, fluxos de conteúdo, trechos de texto e fontes. Tarefas simples como renderizar conteúdo HTML se transformam em operações de várias 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 operação requer o envolvimento do código em blocos Library.Initialize() e Library.Terminate() com descarte cuidadoso de objetos COM. Ignorar as etapas de limpeza leva a vazamentos de recursos e instabilidade do aplicativo.

Exagerado para projetos típicos.

Para aplicações que necessitam principalmente de conversão de HTML para PDF, manipulação básica de documentos ou geração de relatórios, o mecanismo completo do Adobe PDF representa um excesso significativo de complexidade, enquanto soluções mais simples oferecem resultados equivalentes.

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	Empresa com faturamento anual entre US$ 10 mil e US$ 50 mil ou mais	Licenciamento acessível por desenvolvedor
Instalação	DLLs nativas, específicas da plataforma	Pacote NuGet simples
Criação de Documentos	Construção de páginas/conteúdo de baixo nível	Renderização HTML/CSS
Inicialização	`Terminate()` obrigató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	Eliminação manual de objetos COM	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 do `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
dotnet remove package Adobe.PDF.Library.LM.NET

# Install IronPDF
dotnet add package IronPdf

# Remove Adobe PDF Library
dotnet remove package Adobe.PDF.Library.LM.NET

# 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;`
`using Datalogics.PDFL.Document;`	`using IronPdf;`
`using Datalogics.PDFL.Page;`	`using IronPdf;`
`using Datalogics.PDFL.Content;`	`using IronPdf;`

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 As 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(...)`	`PdfDocument.Merge()`

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
`new Watermark(doc, textParams, wmParams)`	`pdf.ApplyWatermark(html)`
`WatermarkParams.Opacity`	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

A simplificação mais drástica ocorre ao converter o conteúdo para PDF. O SDK da Biblioteca PDF da Adobe requer a construção manual de páginas, a incorporação de fontes e o posicionamento de coordenadas.

Implementação do SDK da Biblioteca PDF da Adobe:

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeHtmlToPdf
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            // Adobe PDF Library requires complex setup with HTML conversion parameters
            HTMLConversionParameters htmlParams = new HTMLConversionParameters();
            htmlParams.PaperSize = PaperSize.Letter;
            htmlParams.Orientation = Orientation.Portrait;

            string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

            // Convert HTML to PDF
            Document doc = Document.CreateFromHTML(htmlContent, htmlParams);
            doc.Save(SaveFlags.Full, "output.pdf");
            doc.Dispose();
        }
    }
}

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeHtmlToPdf
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            // Adobe PDF Library requires complex setup with HTML conversion parameters
            HTMLConversionParameters htmlParams = new HTMLConversionParameters();
            htmlParams.PaperSize = PaperSize.Letter;
            htmlParams.Orientation = Orientation.Portrait;

            string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

            // Convert HTML to PDF
            Document doc = Document.CreateFromHTML(htmlContent, htmlParams);
            doc.Save(SaveFlags.Full, "output.pdf");
            doc.Dispose();
        }
    }
}

Imports Datalogics.PDFL
Imports System

Class AdobeHtmlToPdf
    Shared Sub Main()
        Using lib As New Library()
            ' Adobe PDF Library requires complex setup with HTML conversion parameters
            Dim htmlParams As New HTMLConversionParameters()
            htmlParams.PaperSize = PaperSize.Letter
            htmlParams.Orientation = Orientation.Portrait

            Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

            ' Convert HTML to PDF
            Dim doc As Document = Document.CreateFromHTML(htmlContent, htmlParams)
            doc.Save(SaveFlags.Full, "output.pdf")
            doc.Dispose()
        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 utiliza um mecanismo baseado no Chromium para suporte perfeito em CSS e JavaScript . 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:

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeMergePdfs
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            // Open first PDF document
            Document doc1 = new Document("document1.pdf");
            Document doc2 = new Document("document2.pdf");

            // Insert pages from second document into first
            PageInsertParams insertParams = new PageInsertParams();
            insertParams.InsertFlags = PageInsertFlags.None;

            for (int i = 0; i < doc2.NumPages; i++)
            {
                Page page = doc2.GetPage(i);
                doc1.InsertPage(doc1.NumPages - 1, page, insertParams);
            }

            doc1.Save(SaveFlags.Full, "merged.pdf");
            doc1.Dispose();
            doc2.Dispose();
        }
    }
}

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeMergePdfs
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            // Open first PDF document
            Document doc1 = new Document("document1.pdf");
            Document doc2 = new Document("document2.pdf");

            // Insert pages from second document into first
            PageInsertParams insertParams = new PageInsertParams();
            insertParams.InsertFlags = PageInsertFlags.None;

            for (int i = 0; i < doc2.NumPages; i++)
            {
                Page page = doc2.GetPage(i);
                doc1.InsertPage(doc1.NumPages - 1, page, insertParams);
            }

            doc1.Save(SaveFlags.Full, "merged.pdf");
            doc1.Dispose();
            doc2.Dispose();
        }
    }
}

Imports Datalogics.PDFL
Imports System

Class AdobeMergePdfs
    Shared Sub Main()
        Using lib As New Library()
            ' Open first PDF document
            Dim doc1 As New Document("document1.pdf")
            Dim doc2 As New Document("document2.pdf")

            ' Insert pages from second document into first
            Dim insertParams As New PageInsertParams()
            insertParams.InsertFlags = PageInsertFlags.None

            For i As Integer = 0 To doc2.NumPages - 1
                Dim page As Page = doc2.GetPage(i)
                doc1.InsertPage(doc1.NumPages - 1, page, insertParams)
            Next

            doc1.Save(SaveFlags.Full, "merged.pdf")
            doc1.Dispose()
            doc2.Dispose()
        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. 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:

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeAddWatermark
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            Document doc = new Document("input.pdf");

            // Create watermark with complex API
            WatermarkParams watermarkParams = new WatermarkParams();
            watermarkParams.Opacity = 0.5;
            watermarkParams.Rotation = 45.0;
            watermarkParams.VerticalAlignment = WatermarkVerticalAlignment.Center;
            watermarkParams.HorizontalAlignment = WatermarkHorizontalAlignment.Center;

            WatermarkTextParams textParams = new WatermarkTextParams();
            textParams.Text = "CONFIDENTIAL";

            Watermark watermark = new Watermark(doc, textParams, watermarkParams);

            doc.Save(SaveFlags.Full, "watermarked.pdf");
            doc.Dispose();
        }
    }
}

// Adobe PDF Library SDK
using Datalogics.PDFL;
using System;

class AdobeAddWatermark
{
    static void Main()
    {
        using (Library lib = new Library())
        {
            Document doc = new Document("input.pdf");

            // Create watermark with complex API
            WatermarkParams watermarkParams = new WatermarkParams();
            watermarkParams.Opacity = 0.5;
            watermarkParams.Rotation = 45.0;
            watermarkParams.VerticalAlignment = WatermarkVerticalAlignment.Center;
            watermarkParams.HorizontalAlignment = WatermarkHorizontalAlignment.Center;

            WatermarkTextParams textParams = new WatermarkTextParams();
            textParams.Text = "CONFIDENTIAL";

            Watermark watermark = new Watermark(doc, textParams, watermarkParams);

            doc.Save(SaveFlags.Full, "watermarked.pdf");
            doc.Dispose();
        }
    }
}

Imports Datalogics.PDFL
Imports System

Class AdobeAddWatermark
    Shared Sub Main()
        Using lib As New Library()
            Dim doc As New Document("input.pdf")

            ' Create watermark with complex API
            Dim watermarkParams As New WatermarkParams()
            watermarkParams.Opacity = 0.5
            watermarkParams.Rotation = 45.0
            watermarkParams.VerticalAlignment = WatermarkVerticalAlignment.Center
            watermarkParams.HorizontalAlignment = WatermarkHorizontalAlignment.Center

            Dim textParams As New WatermarkTextParams()
            textParams.Text = "CONFIDENTIAL"

            Dim watermark As New Watermark(doc, textParams, watermarkParams)

            doc.Save(SaveFlags.Full, "watermarked.pdf")
            doc.Dispose()
        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

O IronPDF lida com a iteração de páginas automaticamente e suporta marcadores de posição 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);

' Adobe
doc.Save(SaveFlags.Full Or 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.
Verificar 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.

Preparando sua infraestrutura de PDF para o futuro

Com a chegada do .NET 10 e a introdução de novos recursos de linguagem no C# 14, selecionar uma biblioteca PDF for .NET com desenvolvimento ativo garante a compatibilidade com as capacidades de tempo de execução em constante evolução. O compromisso da IronPDF em oferecer suporte às versões mais recentes do .NET significa que seu investimento em migração trará retornos à medida que os projetos se estenderem até 2025 e 2026.

Recursos adicionais

A migração do SDK da Biblioteca PDF da Adobe para o IronPDF simplifica significativamente o código de geração de PDFs e reduz consideravelmente os custos de licenciamento. A mudança da construção de páginas de baixo nível para a renderização em HTML/CSS elimina centenas de linhas de código para cálculo de coordenadas, gerenciamento de fontes e manipulação do ciclo de vida. Para equipes que desenvolvem aplicativos .NET modernos, o IronPDF oferece recursos equivalentes com uma API amigável para desenvolvedores, projetada para fluxos de trabalho de desenvolvimento contemporâneos.

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?

Altos custos de licenciamento

Integração complexa de SDK nativo

Design de API de baixo nível

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

Exagerado para projetos típicos.

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

Preparando sua infraestrutura de PDF para o futuro

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#

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

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

Equipe de suporte de ferro