A biblioteca C# PDF

Explore IronPDF Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

VÍDEOS

Como depurar HTML no Chrome para criar PDFs perfeitos em pixels

Curtis Chau

Updated: 19 de julho de 2026

A migração do iText para o IronPDF move seu fluxo de trabalho PDF do .NET de uma API programática — criando objetos Paragraph, Table e Cell no código — para uma abordagem centrada em HTML com suporte CSS3 e JavaScript. Este guia fornece um caminho de migração passo-a-passo que remove a exposição ao AGPL e a necessidade de um complemento separado pdfHTML.

Por que migrar do iText para o IronPDF?

A Consideração da Licença AGPL

O iText (de propriedade do iText Group / Apryse Group NV) possui características de licenciamento que equipes comerciais devem considerar desde o início:

Licença Viral AGPL: Se você usar o iText sob sua licença de código aberto em um aplicativo web, o AGPL é tipicamente interpretado como exigência de que você libere o código do seu aplicativo para qualquer um que interaja com ele através de uma rede. Para software comercial de código fechado, isso geralmente significa comprar uma licença comercial em vez disso.
Licenciamento Comercial Somente por Assinatura: A licença comercial do iText é vendida como uma assinatura anual baseada no volume de processamento de PDF; uma opção perpétua não é anunciada na página pública de preços (termos personalizados OEM são fornecidos apenas por cotação).
Custo do Add-On pdfHTML: HTML-para-PDF requer o add-on itext.pdfhtml (atualmente 6.3.2), vendido separadamente além do pacote itext (atualmente 9.6.0).
Auditorias de Licenciamento Complexas: Implantação em nível empresarial enfrenta complexidade de licenciamento e risco de auditoria.
API Centrada em Programação: O iText Core constrói PDFs compondo objetos Paragraph, Table e Cell no código; pdfHTML permite que você comece a partir de HTML.
Subconjunto de CSS Definido, Sem JS no Tempo de Renderização: pdfHTML suporta um subconjunto definido de CSS e não executa JavaScript enquanto converte HTML para PDF (ações de formulário no nível PDF são um recurso suportado separado).

Comparação entre iText e IronPDF

Recurso	iText 9 / iTextSharp 5.x	IronPDF
Licença	AGPL (viral) ou assinatura comercial anual	Opção comercial perpétua
HTML para PDF	Add-on `itext.pdfhtml` separado (6.3.2)	Renderizador Chromium integrado
Suporte a CSS	Subconjunto de CSS definido em pdfHTML	CSS3 completo, Flexbox, Grid
JavaScript na renderização	pdfHTML não executa JS durante HTML→PDF	Execução completa de JS no tempo de renderização
Paradigma de API	Programático (Parágrafo, Tabela, Célula)	HTML em primeiro lugar com CSS
Curva de Aprendizagem	Íngreme (sistema de coordenadas PDF)	amigável para desenvolvedores web
Risco de código aberto	Deve abrir o código-fonte dos aplicativos web sob AGPL	Sem requisitos virais
Modelo de Preços	Assinatura anual (baseada em volume) ou OEM personalizado	Perpétuo ou por assinatura

Para equipes padronizando no moderno .NET, a abordagem orientada ao HTML da IronPDF baseia-se nas habilidades de desenvolvimento web que a equipe já possui.

Avaliação da Complexidade da Migração

Esforço estimado por funcionalidade

Recurso	Complexidade da Migração
HTML para PDF	Muito baixo
Mesclar PDFs	Baixo
Texto e imagens	Baixo
Tabelas	Médio
Cabeçalhos/Rodapés	Médio
Segurança/Criptografia	Baixo

Mudança de paradigma

A mudança fundamental nessa migração para o iText é a transição da construção programática de PDFs para a renderização com HTML como primeira opção:

iText: PdfWriter → PdfDocument → Document → Add(Paragraph) → Add(Table)
IronPDF: ChromePdfRenderer → RenderHtmlAsPdf(htmlString) → SaveAs()

iText: PdfWriter → PdfDocument → Document → Add(Paragraph) → Add(Table)
IronPDF: ChromePdfRenderer → RenderHtmlAsPdf(htmlString) → SaveAs()

Text

Essa mudança de paradigma é libertadora: em vez de aprender o modelo de objetos do iText, você usa habilidades de HTML e CSS que os desenvolvedores web já possuem.

Antes de começar

Pré-requisitos

Ambiente .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
Acesso ao NuGet : Capacidade de instalar pacotes NuGet.
Licença do IronPDF: Obtenha sua chave de licença em IronPDF

Alterações no pacote NuGet

# Remove iText packages (current naming is 'itext'; 'itext7' is the deprecated alias)
dotnet remove package itext
dotnet remove package itext.pdfhtml
dotnet remove package itext7
dotnet remove package itext7.pdfhtml
dotnet remove package itextsharp

# Install IronPDF
dotnet add package IronPdf

# Remove iText packages (current naming is 'itext'; 'itext7' is the deprecated alias)
dotnet remove package itext
dotnet remove package itext.pdfhtml
dotnet remove package itext7
dotnet remove package itext7.pdfhtml
dotnet remove package itextsharp

# Install IronPDF
dotnet add package IronPdf

SHELL

Configuração de licença

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

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

Identificar o uso do 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" .

SHELL

Referência completa da API

Mapeamentos de Classes

iText 7+ Classe	iTextSharp 5.x Classe	Equivalente ao IronPDF
`PdfWriter`	`PdfWriter`	`ChromePdfRenderer`
`PdfDocument`	`Document`	`PdfDocument`
`Document`	`Document`	`ChromePdfRenderer.RenderHtmlAsPdf()`
`Paragraph`	`Paragraph`	HTML `<p>`, `<h1>`, etc.
`Table`	`PdfPTable`	HTML `<table>`
`Cell`	`PdfPCell`	HTML `<td>`, `<th>`
`Image`	`Image`	HTML `<img>`
`PdfReader`	`PdfReader`	`PdfDocument.FromFile()`
`PdfMerger`	N / D	`PdfDocument.Merge()`

Mapeamentos de Namespace

Namespace iText	Equivalente ao IronPDF
`iText.Kernel.Pdf`	`IronPdf`
`iText.Layout`	`IronPdf`
`iText.Layout.Element`	Utilize elementos HTML
`iText.Html2pdf`	`IronPdf` (embutido)
`iText.IO.Image`	Use HTML `<img>`
`iText.Kernel.Utils`	`IronPdf`

Exemplos de migração de código

Exemplo 1: Conversão de HTML para PDF

Anteriormente (iText):

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

' NuGet: Install-Package itext7
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 New FileStream(outputPath, FileMode.Create)
            HtmlConverter.ConvertToPdf(html, fs)
        End Using
    End Sub
End Class

' NuGet: Install-Package itext7
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 New FileStream(outputPath, FileMode.Create)
            HtmlConverter.ConvertToPdf(html, fs)
        End Using
    End Sub
End Class

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

' NuGet: Install-Package IronPdf
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

' NuGet: Install-Package IronPdf
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

A abordagem do iText requer o pacote separado itext.pdfhtml (add-on pdfHTML, atualmente 6.3.2, vendido separadamente além do itext 9.6.0), criando um FileStream, e envolvendo tudo em instruções using para descarte adequado. O método HtmlConverter.ConvertToPdf() escreve diretamente no fluxo.

A abordagem do IronPDF é mais limpa: crie um ChromePdfRenderer, chame RenderHtmlAsPdf() com sua string HTML e chame SaveAs() no PdfDocument resultante. Sem pacotes separados, sem gerenciamento de fluxos, e o mecanismo de renderização Chromium oferece suporte superior a CSS3 e JavaScript . Consulte a documentação de conversão de HTML para PDF para obter opções de renderização adicionais.

Exemplo 2: Mesclar vários PDFs

Anteriormente (iText):

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

' NuGet: Install-Package itext7
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),
              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 Sub
End Class

' NuGet: Install-Package itext7
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),
              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 Sub
End Class

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

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.Collections.Generic

Module Program
    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 Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.Collections.Generic

Module Program
    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 Module

A operação de mesclagem do iText requer boilerplate significativo: criando um PdfWriter para saída, envolvendo-o em um PdfDocument, criando um PdfMerger, então iterando através dos arquivos de origem com instruções using aninhadas para cada PdfDocument e PdfReader. Você também deve especificar intervalos de páginas com merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages()).

O IronPDF reduz isso a três etapas: carregar documentos com PdfDocument.FromFile(), chamar o método estático PdfDocument.Merge() com a lista, e salvar. Toda a operação de mesclagem torna-se legível e de fácil manutenção. Saiba mais sobre como mesclar e dividir PDFs .

Exemplo 3: Criar PDF com texto e imagens

Anteriormente (iText):

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

' NuGet: Install-Package itext7
Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports iText.IO.Image

Module Program
    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 Module

' NuGet: Install-Package itext7
Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports iText.IO.Image

Module Program
    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 Module

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

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    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 Module

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    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 Module

Este exemplo ilustra a mudança de paradigma com maior clareza. O iText requer:

Instruções using triplamente aninhadas (PdfWriter, PdfDocument, Document)
Criar objetos Paragraph para cada elemento de texto com new Paragraph()
Usando ImageDataFactory.Create() para carregar imagens
Criar um objeto Image e chamar SetWidth() separadamente
Chamando document.Add() para cada elemento

IronPDF usa HTML padrão: <h1> para cabeçalhos, <p> para parágrafos e <img> para imagens com um atributo width. Os desenvolvedores web podem aproveitar imediatamente suas habilidades existentes, e os designers podem estilizar documentos usando o CSS que já conhecem.

Notas críticas sobre migração

Mudança de paradigma: da programação para o HTML em primeiro lugar

A mudança mais significativa nesta migração para o iText é conceitual. O iText cria PDFs programaticamente:

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

' 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

O IronPDF utiliza HTML e CSS:

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

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

Imports IronPdf

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)

Imports IronPdf

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)

Exposição AGPL Removida

Sob os termos da AGPL do iText, espera-se que um aplicativo web que usa iText libere seu código-fonte para qualquer pessoa que interaja com ele através da rede; a licença comercial é o caminho alternativo. A licença comercial do IronPDF permite a implantação em softwares proprietários sem a necessidade de licenciamento viral.

Não é necessário o complemento pdfHTML.

O iText requer o add-on separado itext.pdfhtml (atualmente 6.3.2) para conversão HTML-para-PDF, vendido além do pacote itext. O IronPDF inclui renderização de HTML baseada em Chromium no pacote base.

Padrões de Substituição de Métodos

Padrão iText	Substituto do IronPDF
`SetTextAlignment(TextAlignment.CENTER)`	CSS `text-align: center`
`SetFontSize(24)`	CSS `font-size: 24px`
`SetBold()`	CSS `font-weight: bold`
`new Table(3)`	HTML `<table>`
`AddHeaderCell(new Cell().Add(new Paragraph()))`	HTML `<th>`
`AddCell(new Cell().Add(new Paragraph()))`	HTML `<td>`

Solução de problemas

Problema 1: Padrão PdfWriter/Documento

Problema: O código usa o padrão de aninhamento PdfWriter → PdfDocument → Document.

Solução: Substitua por 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)

Imports IronPdf

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

Problema 2: HtmlConverter não encontrado

Problema: O código usa iText.Html2pdf.HtmlConverter, que reside no add-on itext.pdfhtml, adquirido separadamente.

Solução: Utilize a renderização HTML integrada do 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)

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

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

Problema 3: Complexidade do PdfMerger

Problema: O PdfMerger do iText requer leitores aninhados e especificação de intervalo de páginas.

Solução: Utilize o método de mesclagem estática do 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")

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

Lista de verificação para migração

Pré-migração

Inventariar todas as chamadas da API iText no código-fonte.
Identificar padrões programáticos de construção de PDF (Parágrafo, Tabela, Célula)
Utilização do HtmlConverter (complemento pdfHTML)
Avaliar o risco de conformidade com a AGPL
Obtenha a chave de licença do IronPDF

Migração de código

Remova os pacotes NuGet do iText: dotnet remove package itext (e o alias descontinuado itext7, além de itext.pdfhtml / iTextSharp se presente)
Instale o pacote NuGet do IronPDF: dotnet add package IronPdf
Atualize as importações de namespace (using iText.* → using IronPdf)
Substitua o padrão Document por ChromePdfRenderer
Converta Cell para elementos HTML
Substitua HtmlConverter.ConvertToPdf() por RenderHtmlAsPdf()
Atualize operações de mesclagem para PdfDocument.Merge()
Adicionar inicialização da chave de licença na inicialização do sistema

Testando

Testar todos os caminhos de geração de PDF
Verificar se a saída visual corresponde às expectativas.
Teste com conteúdo HTML/CSS complexo
Desempenho de referência

Pós-migração

Remover arquivos de licença e referências do iText
Atualizar documentação
Cancelar assinatura do iText (se aplicável)
Arquivar código iText legado

Observe: iText é uma marca registrada de seu respectivo proprietário. Este site não é afiliado, endossado ou patrocinado pelo iText Group. Todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos proprietários. As comparações são apenas para fins informativos e refletem informações disponíveis publicamente no momento da redação.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

...