Cómo migrar de iText a IronPDF en C#

La trampa de la licencia AGPL

iText presenta graves riesgos legales y empresariales para las aplicaciones comerciales que muchos equipos de desarrollo descubren demasiado tarde:

1. Licencia viral AGPL: si usa iText en una aplicación web, la AGPL requiere que abra el código fuente de TODA su aplicación , no solo el código PDF, sino toda su base de código. Esto es imposible para la mayoría del software comercial.

2. Sin licencia perpetua: iText ha eliminado la licencia perpetua, forzando renovaciones de suscripciones anuales que aumentan el costo total de propiedad.

3. Costo del complemento pdfHTML: la funcionalidad de HTML a PDF requiere el complemento pdfHTML, que se vende por separado a un costo adicional a la licencia base.

4. Auditorías de licencias complejas: las implementaciones empresariales enfrentan complejidad de licencias y riesgos de auditoría que pueden retrasar proyectos y crear exposición legal.

5. API solo programática: iText requiere la construcción manual de PDF de bajo nivel con objetos Paragraph, Table, Cell, lo cual resulta tedioso y propenso a errores para diseños complejos.

6. Representación web moderna limitada: incluso con pdfHTML, el contenido complejo de CSS y JavaScriptrequiere un esfuerzo adicional significativo.

Comparación entre iText e IronPDF

Para los equipos que planifican la adopción de .NET 10 y C# 14 hasta 2025 y 2026,IronPDFproporciona una base preparada para el futuro con su enfoque basado en HTML que aprovecha las habilidades de desarrollo web que su equipo ya tiene.

Esfuerzo estimado por función

Cambio de paradigma

El cambio fundamental en esta migración de iText es de la construcción programática de PDF a la representación HTML primero:

iText: PdfWriter → PdfDocument → Documento → Agregar(Párrafo) → Agregar(Tabla)
IronPDF: ChromePdfRenderer → RenderHtmlAsPdf(htmlString) → Guardar como()

Este cambio de paradigma es liberador: en lugar de aprender el modelo de objetos de iText, se utilizan los conocimientos de HTML y CSS que ya poseen los desarrolladores web.

Prerrequisitos

1. Entorno .NET : .NET Framework 4.6.2+ o .NET Core 3.1+ / .NET 5/6/7/8/9+
2. Acceso a NuGet : Capacidad para instalar paquetes NuGet
3. Licencia deIronPDF: Obtenga su clave de licencia en IronPDF

Cambios en el paquete NuGet

# Remove iText packages
dotnet remove package itext7
dotnet remove package itext7.pdfhtml
dotnet remove package itextsharp

# Install IronPDF
dotnet add package IronPdf

# Remove iText packages
dotnet remove package itext7
dotnet remove package itext7.pdfhtml
dotnet remove package itextsharp

# Install IronPDF
dotnet add package IronPdf

Configuración de licencias

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

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

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Identificar el uso de iText

# Find all iText references
grep -r "using iText\|using iTextSharp" --include="*.cs" .
grep -r "PdfWriter\|PdfDocument\|Document\|Paragraph\|Table\|Cell" --include="*.cs" .
grep -r "HtmlConverter\|ConverterProperties" --include="*.cs" .

# Find all iText references
grep -r "using iText\|using iTextSharp" --include="*.cs" .
grep -r "PdfWriter\|PdfDocument\|Document\|Paragraph\|Table\|Cell" --include="*.cs" .
grep -r "HtmlConverter\|ConverterProperties" --include="*.cs" .

Clases

Mapeo de espacios de nombres

Ejemplo 1: Conversión de HTML a PDF

Antes (iText 7):

// NuGet: Install-Package itext7
using iText.Html2pdf;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";
        string outputPath = "output.pdf";

        using (FileStream fs = new FileStream(outputPath, FileMode.Create))
        {
            HtmlConverter.ConvertToPdf(html, fs);
        }
    }
}

// NuGet: Install-Package itext7
using iText.Html2pdf;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";
        string outputPath = "output.pdf";

        using (FileStream fs = new FileStream(outputPath, FileMode.Create))
        {
            HtmlConverter.ConvertToPdf(html, fs);
        }
    }
}

Imports iText.Html2pdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim html As String = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
        Dim outputPath As String = "output.pdf"

        Using fs As FileStream = New FileStream(outputPath, FileMode.Create)
            HtmlConverter.ConvertToPdf(html, fs)
        End Using
    End Sub
End Class

Después (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";

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

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";

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

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

El enfoque iText requiere el paquete separado iText.Html2pdf (complemento pdfHTML, se vende por separado), creando un FileStream y envolviendo todo en declaraciones using para su correcta eliminación. El método HtmlConverter.ConvertToPdf() escribe directamente en la secuencia.

El enfoque deIronPDFes más limpio: crea un ChromePdfRenderer, llama a RenderHtmlAsPdf() con tu cadena HTML y llama a SaveAs() en el PdfDocument resultante. El motor de renderizado Chromium proporciona una compatibilidad superior con CSS3 y JavaScript. Consulte la documentación HTML a PDF para obtener más opciones de conversión.

Ejemplo 2: Combinar varios PDF

Antes (iText 7):

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Kernel.Utils;
using System.IO;

class Program
{
    static void Main()
    {
        string outputPath = "merged.pdf";
        string[] inputFiles = { "document1.pdf", "document2.pdf", "document3.pdf" };

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdfDoc = new PdfDocument(writer))
        {
            PdfMerger merger = new PdfMerger(pdfDoc);

            foreach (string file in inputFiles)
            {
                using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
                {
                    merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
                }
            }
        }
    }
}

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Kernel.Utils;
using System.IO;

class Program
{
    static void Main()
    {
        string outputPath = "merged.pdf";
        string[] inputFiles = { "document1.pdf", "document2.pdf", "document3.pdf" };

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdfDoc = new PdfDocument(writer))
        {
            PdfMerger merger = new PdfMerger(pdfDoc);

            foreach (string file in inputFiles)
            {
                using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
                {
                    merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
                }
            }
        }
    }
}

Imports iText.Kernel.Pdf
Imports iText.Kernel.Utils
Imports System.IO

Class Program
    Shared Sub Main()
        Dim outputPath As String = "merged.pdf"
        Dim inputFiles As String() = {"document1.pdf", "document2.pdf", "document3.pdf"}

        Using writer As New PdfWriter(outputPath)
            Using pdfDoc As New PdfDocument(writer)
                Dim merger As New PdfMerger(pdfDoc)

                For Each file As String In inputFiles
                    Using sourcePdf As New PdfDocument(New PdfReader(file))
                        merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages())
                    End Using
                Next
            End Using
        End Using
    End Sub
End Class

Después (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfDocuments = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        };

        var merged = PdfDocument.Merge(pdfDocuments);
        merged.SaveAs("merged.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfDocuments = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        };

        var merged = PdfDocument.Merge(pdfDocuments);
        merged.SaveAs("merged.pdf");
    }
}

Imports IronPdf
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim pdfDocuments As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        }

        Dim merged = PdfDocument.Merge(pdfDocuments)
        merged.SaveAs("merged.pdf")
    End Sub
End Class

La operación de fusión de iText requiere un código repetitivo significativo: crear un PdfWriter para la salida, envolverlo en un PdfDocument, crear un PdfMerger y luego iterar a través de los archivos fuente con declaraciones using anidadas para cada PdfDocument y PdfReader. También debe especificar rangos de páginas con merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages()).

IronPDF reduce esto a tres pasos: cargar documentos con PdfDocument.FromFile(), llamar al método estático PdfDocument.Merge() con la lista y guardar. Toda la operación de fusión debe ser legible y fácil de mantener. Más información sobre mezclar y dividir archivos PDF.

Ejemplo 3: Crear PDF con texto e imágenes

Antes (iText 7):

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.IO.Image;

class Program
{
    static void Main()
    {
        string outputPath = "document.pdf";

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdf = new PdfDocument(writer))
        using (Document document = new Document(pdf))
        {
            document.Add(new Paragraph("Sample PDF Document"));
            document.Add(new Paragraph("This document contains text and an image."));

            Image img = new Image(ImageDataFactory.Create("image.jpg"));
            img.SetWidth(200);
            document.Add(img);
        }
    }
}

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.IO.Image;

class Program
{
    static void Main()
    {
        string outputPath = "document.pdf";

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdf = new PdfDocument(writer))
        using (Document document = new Document(pdf))
        {
            document.Add(new Paragraph("Sample PDF Document"));
            document.Add(new Paragraph("This document contains text and an image."));

            Image img = new Image(ImageDataFactory.Create("image.jpg"));
            img.SetWidth(200);
            document.Add(img);
        }
    }
}

Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports iText.IO.Image

Class Program
    Shared Sub Main()
        Dim outputPath As String = "document.pdf"

        Using writer As New PdfWriter(outputPath),
              pdf As New PdfDocument(writer),
              document As New Document(pdf)

            document.Add(New Paragraph("Sample PDF Document"))
            document.Add(New Paragraph("This document contains text and an image."))

            Dim img As New Image(ImageDataFactory.Create("image.jpg"))
            img.SetWidth(200)
            document.Add(img)
        End Using
    End Sub
End Class

Después (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

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

        string html = @"
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

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

        string html = @"
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}

Imports IronPdf

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

        Dim html As String = "
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("document.pdf")
    End Sub
End Class

Este ejemplo ilustra el cambio de paradigma con mayor claridad. iText requiere:

• Declaraciones using triplemente anidadas (PdfWriter, PdfDocument, Document)
• Creación de objetos Paragraph para cada elemento de texto con new Paragraph()
• Usando ImageDataFactory.Create() para cargar imágenes
• Crear un objeto Image y llamar a SetWidth() por separado
• Llamando a document.Add() para cada elemento

IronPDF utiliza HTML estándar: <h1> para encabezados, <p> para párrafos y <img> para imágenes con un atributo width. Los desarrolladores web pueden aprovechar inmediatamente sus conocimientos, y los diseñadores pueden dar estilo a los documentos utilizando CSS que ya conocen.

Cambio de paradigma: De programático a HTML-First

El cambio más significativo en esta migración de iText es conceptual. iText crea archivos PDF mediante programación:

// iText approach
document.Add(new Paragraph("Title")
    .SetTextAlignment(TextAlignment.CENTER)
    .SetFontSize(24)
    .SetBold());

var table = new Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth();
table.AddHeaderCell(new Cell().Add(new Paragraph("ID")));
table.AddHeaderCell(new Cell().Add(new Paragraph("Name")));
// ... many more lines

// iText approach
document.Add(new Paragraph("Title")
    .SetTextAlignment(TextAlignment.CENTER)
    .SetFontSize(24)
    .SetBold());

var table = new Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth();
table.AddHeaderCell(new Cell().Add(new Paragraph("ID")));
table.AddHeaderCell(new Cell().Add(new Paragraph("Name")));
// ... many more lines

' iText approach
document.Add(New Paragraph("Title") _
    .SetTextAlignment(TextAlignment.CENTER) _
    .SetFontSize(24) _
    .SetBold())

Dim table = New Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth()
table.AddHeaderCell(New Cell().Add(New Paragraph("ID")))
table.AddHeaderCell(New Cell().Add(New Paragraph("Name")))
' ... many more lines

IronPDF utiliza HTML y CSS:

//IronPDFapproach
string html = @"
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>";

var pdf = renderer.RenderHtmlAsPdf(html);

//IronPDFapproach
string html = @"
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>";

var pdf = renderer.RenderHtmlAsPdf(html);

'IronPDFapproach
Dim html As String = "
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>"

Dim pdf = renderer.RenderHtmlAsPdf(html)

Licencia AGPL eliminada

la licencia AGPL de iText requiere que toda la aplicación web sea de código abierto o que se adquiera una costosa licencia comercial. La licencia comercial deIronPDFpermite la implementación en software propietario sin requisitos de licencia viral.

No requiere complemento pdfHTML

iText requiere el complemento pdfHTML para la conversión de HTML a PDF, que se vende por separado y tiene un coste adicional.IronPDFincluye el renderizado HTML completo basado en Chromium en el paquete base.

Patrones de sustitución de métodos

Número 1: PdfWriter/Patrón de documento

Problema: El código utiliza el patrón de anidamiento PdfWriter → PdfDocument → Document.

Solución: Reemplazar con ChromePdfRenderer:

// Delete this iText pattern:
// using (var writer = new PdfWriter(outputPath))
// using (var pdfDoc = new PdfDocument(writer))
// using (var document = new Document(pdfDoc))

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

// Delete this iText pattern:
// using (var writer = new PdfWriter(outputPath))
// using (var pdfDoc = new PdfDocument(writer))
// using (var document = new Document(pdfDoc))

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

Imports IronPdf

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(outputPath)

Número 2: HtmlConverter Not Found

Problema: el código utiliza iText.Html2pdf.HtmlConverter que requiere el complemento pdfHTML.

Solución: utilice la representación HTML integrada de IronPDF:

// iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream);

//IronPDF(built-in)
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

// iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream);

//IronPDF(built-in)
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

' iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream)

' IronPDF(built-in)
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(outputPath)

Número 3: Complejidad de PdfMerger

Problema: PdfMerger de iText requiere lectores anidados y especificación de rango de páginas.

Solución: utilice el método de combinación estática de IronPDF:

// iText merger pattern (delete this)
// using (PdfDocument pdfDoc = new PdfDocument(writer))
// {
//     PdfMerger merger = new PdfMerger(pdfDoc);
//     foreach (string file in inputFiles)
//     {
//         using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
//         {
//             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
//         }
//     }
// }

//IronPDF(simple)
var merged = PdfDocument.Merge(pdfDocuments);
merged.SaveAs("merged.pdf");

// iText merger pattern (delete this)
// using (PdfDocument pdfDoc = new PdfDocument(writer))
// {
//     PdfMerger merger = new PdfMerger(pdfDoc);
//     foreach (string file in inputFiles)
//     {
//         using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
//         {
//             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
//         }
//     }
// }

//IronPDF(simple)
var merged = PdfDocument.Merge(pdfDocuments);
merged.SaveAs("merged.pdf");

Imports System.Collections.Generic

' iText merger pattern (delete this)
' Using pdfDoc As New PdfDocument(writer)
'     Dim merger As New PdfMerger(pdfDoc)
'     For Each file As String In inputFiles
'         Using sourcePdf As New PdfDocument(New PdfReader(file))
'             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages())
'         End Using
'     Next
' End Using

' IronPDF(simple)
Dim merged = PdfDocument.Merge(pdfDocuments)
merged.SaveAs("merged.pdf")

Pre-Migración

• Inventariar todas las llamadas API de iText en el código base
• Identificar patrones de construcción de PDF programáticos (párrafo, tabla, celda)
• Uso de Document HtmlConverter (complemento pdfHTML)
• Evaluar el riesgo de incumplimiento de AGPL
• Obtener la clave de licencia de IronPDF

Migración de código

• Eliminar paquetes NuGet de iText: dotnet remove package itext7
• Instalar el paquete NuGetIronPDF: dotnet add package IronPdf
• Actualizar las importaciones del espacio de nombres (using iText.* → using IronPdf)
• Reemplace el patrón Document con ChromePdfRenderer
• Convertir Cell en elementos HTML
• Reemplace HtmlConverter.ConvertToPdf() con RenderHtmlAsPdf()
• Actualizar las operaciones de fusión a PdfDocument.Merge()
• Agregar inicialización de clave de licencia al inicio

Pruebas

• Probar todas las rutas de generación de PDF
• Verificar que el resultado visual coincida con las expectativas
• Prueba con contenido HTML/CSS complejo
• Rendimiento de referencia

Posmigración

• Eliminar archivos de licencia y referencias de iText
• Actualización de la documentación
• Cancelar la suscripción a iText (si corresponde)
• Archivar código heredado de iText