GUIAS DE MIGRAçãO

Migrar do ActivePDF para o IronPDF: (Guia .NET)

Atualizado:fevereiro 1, 2026

O ActivePDF tem sido um conjunto de ferramentas PDF confiável para desenvolvedores .NET . No entanto, desde que a Foxit a adquiriu, muitas equipes de desenvolvimento estão incertas quanto ao futuro da plataforma, aos termos de licenciamento e à continuidade do desenvolvimento. Este guia oferece um caminho de migração completo, passo a passo, do ActivePDF para o IronPDF— uma biblioteca .NET PDF moderna e com manutenção ativa, compatível com o .NET Framework 4.6.2 até o .NET 9 e versões posteriores.

Por que considerar migrar do ActivePDF?

A aquisição da ActivePDF pela Foxit trouxe diversos desafios para os desenvolvedores que trabalham em soluções de geração e manipulação de PDFs em aplicações .NET .

Futuro incerto do produto

A transição do ActivePDF para a gestão da Foxit levanta questões sobre o futuro do desenvolvimento da ferramenta. Os desenvolvedores que dependem do ActivePDF enfrentam o risco potencial de a biblioteca se tornar obsoleta, com suporte reduzido e desenvolvimento estagnado. Para equipes que planejam projetos que se estendem até 2025 e 2026, essa incerteza cria um risco técnico significativo.

Complicações de licenciamento

A aquisição gerou incertezas em relação ao licenciamento, o que pode complicar as implementações. O modelo de licenciamento tradicional do ActivePDF, vinculado à máquina, cria atritos em ambientes modernos de nuvem e conteinerizados, onde os aplicativos escalam dinamicamente em toda a infraestrutura.

Padrões de arquitetura legados

A arquitetura do ActivePDF reflete uma filosofia de design mais antiga, centrada em padrões de toolkit com estado. O fluxo de trabalho CloseOutputFile requer gerenciamento explícito de identificadores de arquivo, o que não está alinhado com as convenções modernas de C# e pode introduzir problemas de gerenciamento de recursos se não for tratado com cuidado.

Custos adicionais de instalação e configuração

Ao contrário dos sistemas de gerenciamento de pacotes baseados em NuGet, o ActivePDF geralmente exige referências manuais a DLLs e configuração explícita de caminhos ao instanciar o conjunto de ferramentas — um padrão que aumenta a dificuldade de integração e complica os pipelines de CI/CD.

ActivePDF vs. IronPDF: Principais diferenças

Antes de iniciar o processo de migração, entender as diferenças fundamentais entre ActivePDF e IronPDF ajuda a definir as expectativas em relação às alterações de código necessárias.

Aspecto	ActivePDF	IronPDF
Situação da empresa	Adquirida pela Foxit (futuro incerto)	Roteiro de desenvolvimento independente e claro
Instalação	Referências manuais de DLL	Pacote NuGet simples
Padrão de API	Com estado (`CloseOutputFile`)	API fluente e funcional
Modelo de Licença	Trancado pela máquina	Chave baseada em código
Suporte .NET	Foco no .NET Framework legado	Framework 4.6.2 for .NET 9+
Tratamento de erros	Códigos de retorno inteiros	Moderno baseado em exceções
Suporte assíncrono	Não disponível	Suporte completo a async/await

Preparação pré-migratória

Audite sua base de código

Antes de iniciar a migração, identifique todos os usos do ActivePDF em sua solução. Execute estes comandos no diretório da sua solução:

grep -r "using ActivePDF" --include="*.cs" .
grep -r "using APToolkitNET" --include="*.cs" .
grep -r "APToolkitNET" --include="*.csproj" .

grep -r "using ActivePDF" --include="*.cs" .
grep -r "using APToolkitNET" --include="*.cs" .
grep -r "APToolkitNET" --include="*.csproj" .

SHELL

Documentar alterações significativas

Compreender as diferenças fundamentais da API ajuda a planejar sua estratégia de migração:

Categoria	Comportamento do ActivePDF	Comportamento do IronPDF	Ação contra a migração
Modelo de Objeto	Objeto único `Toolkit`	`ChromePdfRenderer` + `PdfDocument`	preocupações separadas
Operações com arquivos	`CloseOutputFile()`	Direto `SaveAs()`	Remover chamadas abertas/fechadas
Criação de página	Método `NewPage()`	Automático a partir de HTML	Remover chamadas de criação de página
Valores de retorno	Códigos de erro inteiros	Exceções	Implemente o bloco try/catch.
Unidades de tamanho da página	Pontos (612x792 = Letra)	Enums ou milímetros	Atualizar medições

Pré-requisitos

Certifique-se de que seu ambiente atenda a estes requisitos:

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

Processo de migração passo a passo

Passo 1: Atualizar pacotes NuGet

Remova o pacote ActivePDF e instale o IronPDF:

# Remove ActivePDF package
dotnet remove package APToolkitNET

# Install IronPDF
dotnet add package IronPdf

# Remove ActivePDF package
dotnet remove package APToolkitNET

# Install IronPDF
dotnet add package IronPdf

SHELL

Alternativamente, através do Console do Gerenciador de Pacotes do Visual Studio:

Uninstall-Package APToolkitNET
Install-Package IronPdf

Para projetos com referências manuais a DLLs, remova a referência do seu arquivo .csproj:


<Reference Include="APToolkitNET">
    <HintPath>path\to\APToolkitNET.dll</HintPath>
</Reference>


<Reference Include="APToolkitNET">
    <HintPath>path\to\APToolkitNET.dll</HintPath>
</Reference>

XML

Etapa 2: Configurar a chave de licença

Adicione a chave de licença do IronPDF na inicialização do aplicativo, antes de qualquer operação com PDF:

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Verify license status
bool isLicensed = IronPdf.License.IsLicensed;

' Add at application startup (Program.vb or Startup.vb)
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 ActivePDF.Toolkit;`	`using IronPdf;`
`using APToolkitNET;`	`using IronPdf;`
`using APToolkitNET.PDFObjects;`	`using IronPdf;`
`using APToolkitNET.Common;`	`using IronPdf;`

Referência completa para migração de API

Métodos de Criação de Documentos

Método ActivePDF	Equivalente ao IronPDF
`new Toolkit()`	`new ChromePdfRenderer()`
`toolkit.OpenOutputFile(path)`	Não é necessário equivalente.
`toolkit.CloseOutputFile()`	Não é necessário equivalente.
`toolkit.AddHTML(html)`	`renderer.RenderHtmlAsPdf(html)`
`toolkit.AddURL(url)`	`renderer.RenderUrlAsPdf(url)`
`toolkit.SaveAs(path)`	`pdf.SaveAs(path)`

Operações com arquivos

Método ActivePDF	Equivalente ao IronPDF
`toolkit.OpenInputFile(path)`	`PdfDocument.FromFile(path)`
`toolkit.AddPDF(path)`	`PdfDocument.Merge()`
`toolkit.GetPageCount()`	`pdf.PageCount`
`toolkit.GetText()`	`pdf.ExtractAllText()`

Configuração da página

Método ActivePDF	Equivalente ao IronPDF
`toolkit.SetPageSize(612, 792)`	`RenderingOptions.PaperSize = PdfPaperSize.Letter`
`toolkit.SetOrientation("Landscape")`	`RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape`
`toolkit.SetMargins(t, b, l, r)`	`RenderingOptions.MarginTop/Bottom/Left/Right`

Métodos de segurança

Método ActivePDF	Equivalente ao IronPDF
`toolkit.Encrypt(password)`	`pdf.SecuritySettings.OwnerPassword`
`toolkit.SetUserPassword(pwd)`	`pdf.SecuritySettings.UserPassword`
`toolkit.SetPermissions(flags)`	`pdf.SecuritySettings.AllowUserXxx`
`toolkit.AddWatermark(text)`	`pdf.ApplyWatermark(html)`

Exemplos de migração de código

Conversão de HTML para PDF

Converter strings HTML em documentos PDF representa um dos cenários mais comuns de geração de PDFs. Veja como o código se transforma durante a migração.

Implementação do ActivePDF:

// NuGet: Install-Package APToolkitNET
using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

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

        if (toolkit.OpenOutputFile("output.pdf") == 0)
        {
            toolkit.AddHTML(htmlContent);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF created successfully");
        }
    }
}

// NuGet: Install-Package APToolkitNET
using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

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

        if (toolkit.OpenOutputFile("output.pdf") == 0)
        {
            toolkit.AddHTML(htmlContent);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF created successfully");
        }
    }
}

Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

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

        If toolkit.OpenOutputFile("output.pdf") = 0 Then
            toolkit.AddHTML(htmlContent)
            toolkit.CloseOutputFile()
            Console.WriteLine("PDF created successfully")
        End If
    End Sub
End Class

$vbLabelText $csharpLabel

Implementação do IronPDF :

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

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

        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");

        Console.WriteLine("PDF created successfully");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

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

        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");

        Console.WriteLine("PDF created successfully");
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

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

        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")

        Console.WriteLine("PDF created successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

A abordagem IronPDF elimina o gerenciamento explícito de identificadores de arquivos, ao mesmo tempo que proporciona um código mais limpo e legível. Para cenários avançados de conversão de HTML para PDF , o ChromePdfRenderer do IronPDF utiliza um mecanismo de renderização baseado no Chromium para suporte perfeito em CSS e JavaScript .

Conversão de URL para PDF

A captura de páginas da web como documentos PDF segue um padrão de modernização semelhante.

Implementação do ActivePDF:

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string url = "https://www.example.com";

        if (toolkit.OpenOutputFile("webpage.pdf") == 0)
        {
            toolkit.AddURL(url);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF from URL created successfully");
        }
    }
}

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        string url = "https://www.example.com";

        if (toolkit.OpenOutputFile("webpage.pdf") == 0)
        {
            toolkit.AddURL(url);
            toolkit.CloseOutputFile();
            Console.WriteLine("PDF from URL created successfully");
        }
    }
}

Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

        Dim url As String = "https://www.example.com"

        If toolkit.OpenOutputFile("webpage.pdf") = 0 Then
            toolkit.AddURL(url)
            toolkit.CloseOutputFile()
            Console.WriteLine("PDF from URL created successfully")
        End If
    End Sub
End Class

$vbLabelText $csharpLabel

Implementação do IronPDF :

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string url = "https://www.example.com";

        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");

        Console.WriteLine("PDF from URL created successfully");
    }
}

using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string url = "https://www.example.com";

        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");

        Console.WriteLine("PDF from URL created successfully");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim url As String = "https://www.example.com"

        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")

        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

Unir vários PDFs

A combinação de vários documentos PDF em um único arquivo demonstra a abordagem funcional do IronPDF para manipulação de documentos.

Implementação do ActivePDF:

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        if (toolkit.OpenOutputFile("merged.pdf") == 0)
        {
            toolkit.AddPDF("document1.pdf");
            toolkit.AddPDF("document2.pdf");
            toolkit.CloseOutputFile();
            Console.WriteLine("PDFs merged successfully");
        }
    }
}

using ActivePDF.Toolkit;
using System;

class Program
{
    static void Main()
    {
        Toolkit toolkit = new Toolkit();

        if (toolkit.OpenOutputFile("merged.pdf") == 0)
        {
            toolkit.AddPDF("document1.pdf");
            toolkit.AddPDF("document2.pdf");
            toolkit.CloseOutputFile();
            Console.WriteLine("PDFs merged successfully");
        }
    }
}

Imports ActivePDF.Toolkit
Imports System

Class Program
    Shared Sub Main()
        Dim toolkit As New Toolkit()

        If toolkit.OpenOutputFile("merged.pdf") = 0 Then
            toolkit.AddPDF("document1.pdf")
            toolkit.AddPDF("document2.pdf")
            toolkit.CloseOutputFile()
            Console.WriteLine("PDFs merged successfully")
        End If
    End Sub
End Class

$vbLabelText $csharpLabel

Implementação do IronPDF :

using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");

        Console.WriteLine("PDFs merged successfully");
    }
}

using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");

        Console.WriteLine("PDFs merged successfully");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")

        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

Para cenários de mesclagem mais avançados, incluindo extração seletiva de páginas, consulte a documentação de mesclagem de PDF .

Adicionando cabeçalhos e rodapés

Implementação do ActivePDF:

using ActivePDF.Toolkit;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile(outputPath) == 0)
    {
        toolkit.SetHeader("My Document", 12, "Arial");
        toolkit.SetFooter("Page %p of %P", 10, "Arial");
        toolkit.AddHTML(html);
        toolkit.CloseOutputFile();
    }
}

using ActivePDF.Toolkit;

public void CreatePdfWithHeaderFooter(string html, string outputPath)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile(outputPath) == 0)
    {
        toolkit.SetHeader("My Document", 12, "Arial");
        toolkit.SetFooter("Page %p of %P", 10, "Arial");
        toolkit.AddHTML(html);
        toolkit.CloseOutputFile();
    }
}

Imports ActivePDF.Toolkit

Public Sub CreatePdfWithHeaderFooter(html As String, outputPath As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenOutputFile(outputPath) = 0 Then
        toolkit.SetHeader("My Document", 12, "Arial")
        toolkit.SetFooter("Page %p of %P", 10, "Arial")
        toolkit.AddHTML(html)
        toolkit.CloseOutputFile()
    End If
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 = "My Document",
        FontSize = 12,
        FontFamily = "Arial"
    };

    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10,
        FontFamily = "Arial"
    };

    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 = "My Document",
        FontSize = 12,
        FontFamily = "Arial"
    };

    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10,
        FontFamily = "Arial"
    };

    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 = "My Document",
        .FontSize = 12,
        .FontFamily = "Arial"
    }

    renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
        .CenterText = "Page {page} of {total-pages}",
        .FontSize = 10,
        .FontFamily = "Arial"
    }

    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs(outputPath)
    End Using
End Sub

$vbLabelText $csharpLabel

O IronPDF suporta cabeçalhos e rodapés tanto em texto quanto em HTML , proporcionando total flexibilidade de design.

Proteção e segurança por senha

Implementação do ActivePDF:

using ActivePDF.Toolkit;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        toolkit.Encrypt(password);
        toolkit.SetUserPassword(password);
        toolkit.SetPermissions(4); // Print only
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

using ActivePDF.Toolkit;

public void ProtectPdf(string inputPath, string outputPath, string password)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        toolkit.Encrypt(password);
        toolkit.SetUserPassword(password);
        toolkit.SetPermissions(4); // Print only
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

Imports ActivePDF.Toolkit

Public Sub ProtectPdf(inputPath As String, outputPath As String, password As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenInputFile(inputPath) = 0 Then
        toolkit.Encrypt(password)
        toolkit.SetUserPassword(password)
        toolkit.SetPermissions(4) ' Print only
        toolkit.SaveAs(outputPath)
        toolkit.CloseInputFile()
    End If
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.OwnerPassword = password;
    pdf.SecuritySettings.UserPassword = 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.OwnerPassword = password;
    pdf.SecuritySettings.UserPassword = 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.OwnerPassword = password
        pdf.SecuritySettings.UserPassword = password
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights
        pdf.SecuritySettings.AllowUserCopyPasteContent = False
        pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit

        pdf.SaveAs(outputPath)
    End Using
End Sub

$vbLabelText $csharpLabel

A API de configurações de segurança do IronPDF oferece controle granular sobre as permissões de documentos com enumerações fortemente tipadas em vez de sinalizadores inteiros.

Extração de texto

Implementação do ActivePDF:

using ActivePDF.Toolkit;

public string ExtractText(string pdfPath)
{
    Toolkit toolkit = new Toolkit();
    string text = "";

    if (toolkit.OpenInputFile(pdfPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            text += toolkit.GetTextFromPage(i) + "\n";
        }
        toolkit.CloseInputFile();
    }

    return text;
}

using ActivePDF.Toolkit;

public string ExtractText(string pdfPath)
{
    Toolkit toolkit = new Toolkit();
    string text = "";

    if (toolkit.OpenInputFile(pdfPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            text += toolkit.GetTextFromPage(i) + "\n";
        }
        toolkit.CloseInputFile();
    }

    return text;
}

Imports ActivePDF.Toolkit

Public Function ExtractText(pdfPath As String) As String
    Dim toolkit As New Toolkit()
    Dim text As String = ""

    If toolkit.OpenInputFile(pdfPath) = 0 Then
        Dim pageCount As Integer = toolkit.GetPageCount()
        For i As Integer = 1 To pageCount
            text &= toolkit.GetTextFromPage(i) & vbCrLf
        Next
        toolkit.CloseInputFile()
    End If

    Return text
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 implementação do IronPDF reduz a extração de texto de várias linhas a uma única chamada de método.

Adicionando marcas d'água

Implementação do ActivePDF:

using ActivePDF.Toolkit;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            toolkit.SetPage(i);
            toolkit.AddWatermark(watermarkText, 45, 0.5f);
        }
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

using ActivePDF.Toolkit;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenInputFile(inputPath) == 0)
    {
        int pageCount = toolkit.GetPageCount();
        for (int i = 1; i <= pageCount; i++)
        {
            toolkit.SetPage(i);
            toolkit.AddWatermark(watermarkText, 45, 0.5f);
        }
        toolkit.SaveAs(outputPath);
        toolkit.CloseInputFile();
    }
}

Imports ActivePDF.Toolkit

Public Sub AddWatermark(inputPath As String, outputPath As String, watermarkText As String)
    Dim toolkit As New Toolkit()

    If toolkit.OpenInputFile(inputPath) = 0 Then
        Dim pageCount As Integer = toolkit.GetPageCount()
        For i As Integer = 1 To pageCount
            toolkit.SetPage(i)
            toolkit.AddWatermark(watermarkText, 45, 0.5F)
        Next
        toolkit.SaveAs(outputPath)
        toolkit.CloseInputFile()
    End If
End Sub

$vbLabelText $csharpLabel

Implementação do IronPDF :

using IronPdf;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.ApplyWatermark(
        $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
        rotation: 45,
        opacity: 50);

    pdf.SaveAs(outputPath);
}

using IronPdf;

public void AddWatermark(string inputPath, string outputPath, string watermarkText)
{
    using var pdf = PdfDocument.FromFile(inputPath);

    pdf.ApplyWatermark(
        $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
        rotation: 45,
        opacity: 50);

    pdf.SaveAs(outputPath);
}

Imports IronPdf

Public Sub AddWatermark(inputPath As String, outputPath As String, watermarkText As String)
    Using pdf = PdfDocument.FromFile(inputPath)
        pdf.ApplyWatermark(
            $"<h1 style='color:lightgray;font-size:72px;'>{watermarkText}</h1>",
            rotation:=45,
            opacity:=50)

        pdf.SaveAs(outputPath)
    End Using
End Sub

$vbLabelText $csharpLabel

A marca d'água baseada em HTML do IronPDF permite a estilização em CSS para controle total do design, sem necessidade de iteração página por página.

Integração com ASP.NET Core

Aplicações web modernas se beneficiam significativamente dos padrões de integração mais claros do IronPDF.

Padrão ActivePDF:

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile("temp.pdf") == 0)
    {
        toolkit.AddHTML(request.Html);
        toolkit.CloseOutputFile();

        byte[] bytes = System.IO.File.ReadAllBytes("temp.pdf");
        return File(bytes, "application/pdf", "report.pdf");
    }

    return BadRequest("PDF generation failed");
}

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    Toolkit toolkit = new Toolkit();

    if (toolkit.OpenOutputFile("temp.pdf") == 0)
    {
        toolkit.AddHTML(request.Html);
        toolkit.CloseOutputFile();

        byte[] bytes = System.IO.File.ReadAllBytes("temp.pdf");
        return File(bytes, "application/pdf", "report.pdf");
    }

    return BadRequest("PDF generation failed");
}

<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
    Dim toolkit As New Toolkit()

    If toolkit.OpenOutputFile("temp.pdf") = 0 Then
        toolkit.AddHTML(request.Html)
        toolkit.CloseOutputFile()

        Dim bytes As Byte() = System.IO.File.ReadAllBytes("temp.pdf")
        Return File(bytes, "application/pdf", "report.pdf")
    End If

    Return BadRequest("PDF generation failed")
End Function

$vbLabelText $csharpLabel

Padrão IronPDF :

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(request.Html);

    return File(pdf.BinaryData, "application/pdf", "report.pdf");
}

[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(request.Html);

    return File(pdf.BinaryData, "application/pdf", "report.pdf");
}

<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
    Dim renderer As New ChromePdfRenderer()
    Using pdf = renderer.RenderHtmlAsPdf(request.Html)
        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Using
End Function

$vbLabelText $csharpLabel

O IronPDF elimina a necessidade de arquivos temporários, retornando os dados binários do PDF diretamente da memória.

Suporte assíncrono para aplicações web

O ActivePDF não possui suporte nativo para operações assíncronas. O IronPDF oferece recursos completos de async/await, essenciais para aplicações web escaláveis:

using IronPdf;

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}

using IronPdf;

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}

Imports IronPdf

Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Dim renderer As New ChromePdfRenderer()
    Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
        Return pdf.BinaryData
    End Using
End Function

$vbLabelText $csharpLabel

Configuração de Injeção de Dependência

Para aplicações .NET 6+, registre os serviços IronPDF no seu contêiner de injeção de dependência:

// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();

// Service wrapper
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
    Task<byte[]> GeneratePdfFromUrlAsync(string url);
}

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

    public async Task<byte[]> GeneratePdfFromUrlAsync(string url)
    {
        using var pdf = await _renderer.RenderUrlAsPdfAsync(url);
        return pdf.BinaryData;
    }
}

// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();

// Service wrapper
public interface IPdfService
{
    Task<byte[]> GeneratePdfAsync(string html);
    Task<byte[]> GeneratePdfFromUrlAsync(string url);
}

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

    public async Task<byte[]> GeneratePdfFromUrlAsync(string url)
    {
        using var pdf = await _renderer.RenderUrlAsPdfAsync(url);
        return pdf.BinaryData;
    }
}

Imports Microsoft.Extensions.DependencyInjection
Imports System.Threading.Tasks

' Program.vb (.NET 6+)
builder.Services.AddSingleton(Of ChromePdfRenderer)()

' Service wrapper
Public Interface IPdfService
    Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Function GeneratePdfFromUrlAsync(url 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

    Public Async Function GeneratePdfFromUrlAsync(url As String) As Task(Of Byte()) Implements IPdfService.GeneratePdfFromUrlAsync
        Using pdf = Await _renderer.RenderUrlAsPdfAsync(url)
            Return pdf.BinaryData
        End Using
    End Function
End Class

$vbLabelText $csharpLabel

Migração de tratamento de erros

O ActivePDF usa códigos de retorno inteiros que exigem tabelas de consulta. O IronPDF utiliza tratamento de exceções moderno:

Tratamento de erros do ActivePDF:

Toolkit toolkit = new Toolkit();
int result = toolkit.OpenOutputFile(path);

if (result != 0)
{
    // Error - need to look up error code
    Console.WriteLine($"Error code: {result}");
}

Toolkit toolkit = new Toolkit();
int result = toolkit.OpenOutputFile(path);

if (result != 0)
{
    // Error - need to look up error code
    Console.WriteLine($"Error code: {result}");
}

Dim toolkit As New Toolkit()
Dim result As Integer = toolkit.OpenOutputFile(path)

If result <> 0 Then
    ' Error - need to look up error code
    Console.WriteLine($"Error code: {result}")
End If

$vbLabelText $csharpLabel

Tratamento de erros do IronPDF :

try
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(path);
}
catch (IronPdf.Exceptions.IronPdfProductException ex)
{
    Console.WriteLine($"IronPDF Error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General Error: {ex.Message}");
}

try
{
    var renderer = new ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(path);
}
catch (IronPdf.Exceptions.IronPdfProductException ex)
{
    Console.WriteLine($"IronPDF Error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General Error: {ex.Message}");
}

Imports IronPdf.Exceptions

Try
    Dim renderer = New ChromePdfRenderer()
    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs(path)
    End Using
Catch ex As IronPdfProductException
    Console.WriteLine($"IronPDF Error: {ex.Message}")
Catch ex As Exception
    Console.WriteLine($"General Error: {ex.Message}")
End Try

$vbLabelText $csharpLabel

Dicas de Otimização de Desempenho

Reutilizar a instância do renderizador

A criação de um novo ChromePdfRenderer tem sobrecarga de inicialização. Para operações em lote, reutilize uma única instância:

var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
    using var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"output_{i}.pdf");
}

Imports IronPdf

Dim renderer As New ChromePdfRenderer()
For Each html In htmlList
    Using pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs($"output_{i}.pdf")
    End Using
Next

$vbLabelText $csharpLabel

Utilize Async em Aplicações Web

Para aplicações ASP.NET Core , a geração assíncrona de PDFs melhora o desempenho:

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

Descarte adequado de recursos

Utilize sempre as instruções using para garantir a limpeza adequada:

using var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;

using var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;

$vbLabelText $csharpLabel

Compressão de imagem

Reduza o tamanho dos arquivos de saída com a compressão de imagens:

using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.CompressImages(85); // 85% quality
pdf.SaveAs("compressed.pdf");

using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.CompressImages(85); // 85% quality
pdf.SaveAs("compressed.pdf");

$vbLabelText $csharpLabel

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

Problema: Diferenças no tamanho das páginas

O ActivePDF usa pontos (612x792 = Carta), enquanto o IronPDF usa enumerações ou milímetros:

// ActivePDF: Points
toolkit.SetPageSize(612, 792);

// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4);

// ActivePDF: Points
toolkit.SetPageSize(612, 792);

// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4);

' ActivePDF: Points
toolkit.SetPageSize(612, 792)

' IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
' Or custom in mm:
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(215.9, 279.4)

$vbLabelText $csharpLabel

Problema: Ausência de equivalente para CloseOutputFile

O IronPDF utiliza um paradigma moderno sem gerenciamento explícito de identificadores de arquivos:

// ActivePDF
toolkit.OpenOutputFile(path);
toolkit.AddHTML(html);
toolkit.CloseOutputFile(); // Required!

// IronPDF - no open/close needed
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path); // 'using' handles cleanup

// ActivePDF
toolkit.OpenOutputFile(path);
toolkit.AddHTML(html);
toolkit.CloseOutputFile(); // Required!

// IronPDF - no open/close needed
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path); // 'using' handles cleanup

' ActivePDF
toolkit.OpenOutputFile(path)
toolkit.AddHTML(html)
toolkit.CloseOutputFile() ' Required!

' IronPDF - no open/close needed
Using pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs(path) ' 'Using' handles cleanup
End Using

$vbLabelText $csharpLabel

Problema: PDF é renderizado em branco

Se o conteúdo dependente de JavaScript for exibido em branco, configure os atrasos de renderização:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
// Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
// Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.RenderDelay(2000)
' Or wait for element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded")

$vbLabelText $csharpLabel

Problema: CSS/Imagens não estão carregando

Configure o URL base para resolução de caminho relativo:

renderer.RenderingOptions.BaseUrl = new Uri("https://yourdomain.com/assets/");

renderer.RenderingOptions.BaseUrl = new Uri("https://yourdomain.com/assets/");

renderer.RenderingOptions.BaseUrl = New Uri("https://yourdomain.com/assets/")

$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)
Comparar o desempenho com a implementação anterior.
Remova os arquivos de instalação antigos do ActivePDF e as referências a DLLs.
Atualizar dependências do pipeline CI/CD
Documente os padrões do IronPDF para sua equipe de desenvolvimento.

Garantindo a compatibilidade futura da sua solução em PDF

Com o .NET 10 no horizonte e o C# 14 introduzindo novos recursos de linguagem, escolher uma biblioteca .NET PDF com desenvolvimento ativo garante que seus aplicativos permaneçam compatíveis com os recursos 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 seus projetos se estenderem até 2025 e 2026.

Recursos adicionais

A migração do ActivePDF para o IronPDF moderniza sua infraestrutura de geração de PDFs com APIs mais limpas, melhor integração com o .NET e suporte ativo a longo prazo. O investimento em migração compensa através da melhoria na manutenção do código, recursos assíncronos e confiança no desenvolvimento contínuo da sua biblioteca de PDFs.

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.

Migrar do ActivePDF para o IronPDF: (Guia .NET)

Por que considerar migrar do ActivePDF?

Futuro incerto do produto

Complicações de licenciamento

Padrões de arquitetura legados

Custos adicionais de instalação e configuração

ActivePDF vs. IronPDF: Principais diferenças

Preparação pré-migratória

Audite sua base de código

Documentar alterações significativas

Pré-requisitos

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

Referência completa para migração de API

Métodos de Criação de Documentos

Operações com arquivos

Configuração da página

Métodos de segurança

Exemplos de migração de código

Conversão de HTML para PDF

Conversão de URL para PDF

Unir vários PDFs

Adicionando cabeçalhos e rodapés

Proteção e segurança por senha

Extração de texto

Adicionando marcas d'água

Integração com ASP.NET Core

Suporte assíncrono para aplicações web

Configuração de Injeção de Dependência

Migração de tratamento de erros

Dicas de Otimização de Desempenho

Reutilizar a instância do renderizador

Utilize Async em Aplicações Web

Descarte adequado de recursos

Compressão de imagem

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

Problema: Diferenças no tamanho das páginas

Problema: Ausência de equivalente para CloseOutputFile

Problema: PDF é renderizado em branco

Problema: CSS/Imagens não estão carregando

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

Garantindo a compatibilidade futura da sua solução em PDF

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