GUíAS DE MIGRACIóN

Migración de ActivePDF a IronPDF: (Guía .NET)

Actualizado:1 de febrero de 2026

ActivePDF ha sido un kit de herramientas PDF confiable para desarrolladores .NET . Sin embargo, desde que Foxit la adquirió, muchos equipos de desarrollo tienen incertidumbre sobre el futuro de la plataforma, los términos de la licencia y el desarrollo continuo. Esta guía ofrece una ruta de migración completa, paso a paso, de ActivePDFa IronPDF, una biblioteca de PDF .NET moderna y con mantenimiento activo que admite .NET Framework 4.6.2 hasta .NET 9 y posteriores.

¿Por qué considerar dejar de usar ActivePDF?

La adquisición de ActivePDFpor parte de Foxit ha introducido varios desafíos para los desarrolladores que trabajan en soluciones de generación y manipulación de PDF en aplicaciones .NET .

Futuro incierto del producto

La transición de ActivePDFbajo la propiedad de Foxit plantea preguntas sobre la trayectoria de desarrollo a largo plazo del kit de herramientas. Los desarrolladores que dependen de ActivePDFenfrentan riesgos potenciales de que la biblioteca quede obsoleta debido a un soporte reducido y un desarrollo estancado. Para los equipos que planifican proyectos que se extienden hasta 2025 y 2026, esta incertidumbre crea un riesgo técnico significativo.

Complicaciones de las licencias

La adquisición ha introducido incertidumbres en materia de licencias que pueden complicar las implantaciones. El modelo de licencia tradicional de ActivePDF, basado en máquinas, crea fricciones en los entornos modernos de nube y contenedores, en los que las aplicaciones se escalan dinámicamente a través de la infraestructura.

Patrones de arquitectura de Legacy

La arquitectura de ActivePDFrefleja una filosofía de diseño más antigua centrada en patrones de conjunto de herramientas con estado. El flujo de trabajo CloseOutputFile requiere una administración explícita de los identificadores de archivos que no se alinea con las convenciones modernas de C# y puede generar problemas de administración de recursos si no se maneja con cuidado.

Instalación y configuración

A diferencia de la gestión de paquetes actual basada en NuGet, ActivePDFa menudo requiere referencias DLL manuales y una configuración de ruta explícita al instanciar el kit de herramientas, un patrón que aumenta la fricción de la incorporación y complica las canalizaciones de CI/CD.

ActivePDFfrente a IronPDF: Diferencias clave

Antes de comenzar el proceso de migración, comprender las diferencias fundamentales entre ActivePDFeIronPDFayuda a establecer expectativas para los cambios de código necesarios.

Aspecto	ActivePDF	IronPDF
Estado de la empresa	Adquirida por Foxit (futuro incierto)	Hoja de ruta de desarrollo independiente y clara
Instalación	Referencias DLL manuales	Paquete simple NuGet
Patrón API	Con estado (`CloseOutputFile`)	API fluida y funcional
Modelo de licencia	Bloqueado por máquina	Clave basada en el código
Soporte .NET	Enfoque del legado .NET Framework	De .NET Framework 4.6.2 a .NET 9+
Manejo de errores	Códigos enteros de retorno	Moderno basado en excepciones
Soporte Async	No disponible	Soporte completo de async/await

Preparación de la migración

Audite su base de código

Antes de comenzar la migración, identifique todo el uso de ActivePDFen su solución. Ejecute estos comandos en su directorio de soluciones:

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

Cambios de última hora en el documento

Comprender las diferencias fundamentales entre las API ayuda a planificar la estrategia de migración:

Categoría	Comportamiento de ActivePDF	Comportamiento de IronPDF	Acción de migración
Modelo de objeto	Objeto único `Toolkit`	`ChromePdfRenderer` + `PdfDocument`	Cuestiones aparte
Operaciones con archivos	`CloseOutputFile()`	Directo `SaveAs()`	Eliminar las llamadas de apertura/cierre
Creación de páginas	`NewPage()` método	Automática a partir de HTML	Eliminar las llamadas a la creación de páginas
Valores de retorno	Códigos de error enteros	Excepciones	Implementar try/catch
Unidades de tamaño de página	Puntos (612x792 = Carta)	Enumeraciones o milímetros	Medidas de actualización

Prerrequisitos

Asegúrese de que su entorno cumple estos requisitos:

.NET Framework 4.6.2+ o .NET Core 3.1 / .NET 5-9
Visual Studio 2019+ o JetBrains Rider
Acceso al gestor de paquetes NuGet
Clave de licencia deIronPDF(prueba gratuita disponible en ironpdf.com)

Proceso de migración paso a paso

Paso 1: Actualizar paquetes NuGet

Elimine el paquete ActivePDFe instale IronPDF:

# Remove ActivePDFpackage
dotnet remove package APToolkitNET

# Install IronPDF
dotnet add package IronPdf

# Remove ActivePDFpackage
dotnet remove package APToolkitNET

# Install IronPDF
dotnet add package IronPdf

SHELL

Alternativamente, a través de la consola del gestor de paquetes de Visual Studio:

Uninstall-Package APToolkitNET
Install-Package IronPdf

Para proyectos con referencias DLL manuales, elimine la referencia de su archivo .csproj:


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


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

XML

Paso 2: Configurar la clave de licencia

Añada la clave de licencia deIronPDFal iniciar la aplicación, antes de cualquier operación con 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

Paso 3: Actualizar referencias de espacios de nombres

Realice una búsqueda y sustitución global en toda la solución:

Visite	Sustituir por
`using ActivePDF.Toolkit;`	`using IronPdf;`
`using APToolkitNET;`	`using IronPdf;`
`using APToolkitNET.PDFObjects;`	`using IronPdf;`
`using APToolkitNET.Common;`	`using IronPdf;`

Referencia completa de migración de API

Métodos de creación de documentos

Método ActivePDF	Equivalente de IronPDF
`new Toolkit()`	`new ChromePdfRenderer()`
`toolkit.OpenOutputFile(path)`	No se necesitan equivalentes
`toolkit.CloseOutputFile()`	No se necesitan equivalentes
`toolkit.AddHTML(html)`	`renderer.RenderHtmlAsPdf(html)`
`toolkit.AddURL(url)`	`renderer.RenderUrlAsPdf(url)`
`toolkit.SaveAs(path)`	`pdf.SaveAs(path)`

Operaciones con archivos

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

Configuración de la página

Método ActivePDF	Equivalente de 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 seguridad

Método ActivePDF	Equivalente de 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)`

Ejemplos de migración de código

Conversión de HTML a PDF

La conversión de cadenas HTML a documentos PDF representa uno de los escenarios de generación de PDF más comunes. Así es como se transforma el código durante la migración.

Implementación de 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

Implementación de 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

El enfoque deIronPDFelimina la gestión explícita del manejo de archivos y proporciona un código más limpio y legible. Para escenarios avanzados de conversión de HTML a PDF , ChromePdfRenderer deIronPDFutiliza un motor de renderizado basado en Chromium para compatibilidad con CSS y JavaScript con precisión de píxeles.

Conversión de URL a PDF

La captura de páginas web como documentos PDF sigue un patrón de modernización similar.

Implementación de 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

Implementación de 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

Fusión de varios PDF

La combinación de varios documentos PDF en un único archivo demuestra el enfoque funcional deIronPDFpara la manipulación de documentos.

Implementación de 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

Implementación de 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 situaciones de fusión más avanzadas, incluida la extracción selectiva de páginas, consulte la documentación sobre fusión de PDF.

Añadir encabezados y pies de página

Implementación de 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

Implementación de 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

IronPDF es compatible con encabezados y pies de página HTML y basados en texto, lo que proporciona una flexibilidad de diseño total.

Protección y seguridad de contraseñas

Implementación de 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

Implementación de 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

La API de configuración de seguridad deIronPDFproporciona un control granular sobre los permisos de los documentos con enums fuertemente tipados en lugar de indicadores enteros.

Extracción de texto

Implementación de 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

Implementación de 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

La implementación deIronPDFreduce la extracción de texto de varias líneas a una única llamada a un método.

Añadir marcas de agua

Implementación de 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

Implementación de 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

El marcado de agua basado en HTML deIronPDFpermite el estilo CSS para un control total del diseño sin necesidad de iterar página por página.

Integración con .NET Core

Las aplicaciones web modernas se benefician significativamente de los patrones de integración más limpios de IronPDF.

Patrón 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

Patrón 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

IronPDF elimina la necesidad de archivos temporales, devolviendo los datos binarios PDF directamente desde la memoria.

Soporte asíncrono para aplicaciones web

ActivePDF carece de soporte nativo async.IronPDFofrece todas las funciones async/await esenciales para las aplicaciones web escalables:

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

Configuración de la inyección de dependencias

Para aplicaciones .NET 6+, registre los serviciosIronPDFen su contenedor DI:

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

Migración de la gestión de errores

ActivePDF utiliza códigos de retorno enteros que requieren tablas de consulta.IronPDFutiliza un moderno sistema de gestión de excepciones:

Manejo de errores de 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

Manejo de errores de 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

Consejos para optimizar el rendimiento

Reutilizar la instancia del renderizador

La creación de un nuevo ChromePdfRenderer tiene una sobrecarga de inicialización. Para operaciones por lotes, reutilice una única instancia:

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

Utilizar Async en aplicaciones web

Para las aplicaciones ASP.NET Core, la generación asíncrona de PDF mejora el rendimiento:

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

Disposición adecuada de recursos

Utilice siempre las declaraciones using para garantizar una limpieza adecuada:

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

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

$vbLabelText $csharpLabel

Compresión de imágenes

Reduzca el tamaño de los archivos de salida con la compresión de imágenes:

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

Solución de problemas comunes de migración

Asunto: Diferencias de tamaño de página

ActivePDF utiliza puntos (612x792 = Letter), mientras queIronPDFutiliza enums o 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

Asunto: Falta el equivalente de CloseOutputFile

IronPDF utiliza un paradigma moderno sin gestión explícita de gestores de archivos:

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

Asunto: PDF Renders Blank

Si el contenido que depende de JavaScript se muestra en blanco, configure retrasos en la renderización:

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

Asunto: CSS/Imágenes no se cargan

Configure la URL base para la resolución de rutas relativas:

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 comprobación posterior a la migración

Después de completar la migración del código, verifique lo siguiente:

Ejecutar todas las pruebas unitarias y de integración existentes
Comparar visualmente las salidas PDF con versiones anteriores
Pruebe todos los flujos de trabajo de PDF en un entorno de prueba
Verificar que el licenciamiento funcione correctamente (IronPdf.License.IsLicensed)
Rendimiento comparativo con la implementación anterior
Eliminar archivos de instalación antiguos de ActivePDFy referencias DLL
Actualizar las dependencias de la canalización de CI/CD
Documente los patrones deIronPDFpara su equipo de desarrollo

Proteja su solución PDF para el futuro

Con .NET 10 en el horizonte y C# 14 introduciendo nuevas características del lenguaje, elegir una biblioteca PDF .NET con desarrollo activo garantiza que sus aplicaciones sigan siendo compatibles con las capacidades de tiempo de ejecución en evolución. El compromiso deIronPDFde admitir las últimas versiones de .NET significa que su inversión en migración le reportará beneficios cuando sus proyectos se extiendan hasta 2025 y 2026.

Recursos adicionales

La migración de ActivePDFaIronPDFmoderniza su infraestructura de generación de PDF con API más limpias, mejor integración .NET y soporte activo a largo plazo. La inversión en la migración resulta rentable gracias a la mejora del mantenimiento del código, las capacidades asíncronas y la confianza en el desarrollo continuo de la biblioteca PDF.

Curtis Chau

Chatea con el equipo de ingeniería ahora

Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Comience una prueba gratuita de 30 días

Migración de ActivePDF a IronPDF: (Guía .NET)

¿Por qué considerar dejar de usar ActivePDF?

Futuro incierto del producto

Complicaciones de las licencias

Patrones de arquitectura de Legacy

Instalación y configuración

ActivePDFfrente a IronPDF: Diferencias clave

Preparación de la migración

Audite su base de código

Cambios de última hora en el documento

Prerrequisitos

Proceso de migración paso a paso

Paso 1: Actualizar paquetes NuGet

Paso 2: Configurar la clave de licencia

Paso 3: Actualizar referencias de espacios de nombres

Referencia completa de migración de API

Métodos de creación de documentos

Operaciones con archivos

Configuración de la página

Métodos de seguridad

Ejemplos de migración de código

Conversión de HTML a PDF

Conversión de URL a PDF

Fusión de varios PDF

Añadir encabezados y pies de página

Protección y seguridad de contraseñas

Extracción de texto

Añadir marcas de agua

Integración con .NET Core

Soporte asíncrono para aplicaciones web

Configuración de la inyección de dependencias

Migración de la gestión de errores

Consejos para optimizar el rendimiento

Reutilizar la instancia del renderizador

Utilizar Async en aplicaciones web

Disposición adecuada de recursos

Compresión de imágenes

Solución de problemas comunes de migración

Asunto: Diferencias de tamaño de página

Asunto: Falta el equivalente de CloseOutputFile

Asunto: PDF Renders Blank

Asunto: CSS/Imágenes no se cargan

Lista de comprobación posterior a la migración

Proteja su solución PDF para el futuro

Recursos adicionales

Artículos Relacionados

Cómo migrar de ZetPDF a IronPDF en C#

Cómo migrar de Scryber.Core a IronPDF en C#

Cómo migrar de XFINIUM.PDF a IronPDF en 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?

Confiado por millones de ingenieros en todo el mundo

Equipo de soporte de Iron