Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Guias de Migração
  4. Migração do zetpdf para o ironpdf
GUIAS DE MIGRAçãO

Como migrar do ZetPDF para o IronPDF em C#

Curtis Chau
Curtis Chau
Atualizado:

ZetPDF é uma biblioteca PDF com licença comercial para aplicações C#, construída sobre a base da biblioteca de código aberto PDFSharp, amplamente utilizada. Embora o ZetPDF ofereça suporte comercial e recursos básicos de manipulação de PDF, ele herda limitações significativas de sua base PDFSharp. Mais notavelmente, a biblioteca depende de programação gráfica baseada em coordenadas e oferece capacidades limitadas de conversão de HTML para PDF em comparação com alternativas modernas.

Este guia fornece um caminho completo de migração do ZetPDF para o IronPDF, com instruções passo a passo, comparações de código e exemplos práticos para desenvolvedores .NET profissionais que estejam avaliando essa transição.

Por que migrar do ZetPDF?

O ZetPDF, por ser um fork do PDFSharp, herda as mesmas limitações arquitetônicas que restringem sua eficácia para fluxos de trabalho modernos de geração de documentos. Os principais motivos pelos quais as equipes de desenvolvimento consideram a migração incluem:

API baseada em coordenadas: o ZetPDF força os desenvolvedores a posicionarem cada elemento com coordenadas exatas. O posicionamento manual complexo de cada elemento cria desafios de manutenção à medida que os requisitos mudam.

Suporte limitado a CSS: A ausência de um sistema de estilização significa que o gerenciamento de fontes e cores para cada elemento é manual.

Sem renderização de JavaScript : Não é possível renderizar conteúdo web dinâmico nem executar JavaScript durante a geração do PDF.

Ofertas exclusivas limitadas: em comparação com o uso direto e gratuito do PDFSharp, o ZetPDF oferece poucos motivos convincentes que justifiquem sua licença comercial.

Quebras de página manuais: É necessário calcular e gerenciar manualmente o excesso de páginas, em vez de depender da paginação automática.

Necessidade de medição de texto: O cálculo manual para quebra de texto gera sobrecarga adicional de desenvolvimento.

O problema fundamental

O ZetPDF e o PDFSharp obrigam você a posicionar cada elemento com coordenadas exatas:

// ZetPDF: Manual positioning nightmare
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form
// ZetPDF: Manual positioning nightmare
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form
' ZetPDF: Manual positioning nightmare
graphics.DrawString("Name:", font, brush, New XPoint(50, 100))
graphics.DrawString("John Doe", font, brush, New XPoint(100, 100))
graphics.DrawString("Address:", font, brush, New XPoint(50, 120))
graphics.DrawString("123 Main St", font, brush, New XPoint(100, 120))
' ... hundreds of lines for a simple form
$vbLabelText   $csharpLabel

O IronPDF usa HTML/CSS — o mecanismo de layout cuida de tudo:

// IronPDF: Simple HTML
var html = @"
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
// IronPDF: Simple HTML
var html = @"
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
' IronPDF: Simple HTML
Dim html As String = "
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

IronPDF vs ZetPDF: Comparação de Recursos

Compreender as diferenças arquitetônicas ajuda os responsáveis ​​pelas decisões técnicas a avaliar o investimento em migração:

Recurso ZetPDF IronPDF
Com base no PDFSharp Sim Não
Conversão de HTML para PDF Limitado Sim (Chromium completo)
Licença Comercial Sim, Perpétuo Sim
Fundação de Código Aberto PDFSharp (Licença MIT) Baseado em cromo
Suporte a CSS Não CSS3 completo
JavaScript Não ES2024 completo
Layout automático Não Sim
Quebras de página automáticas Não Sim
Tabelas Desenho manual HTML <table>
Cabeçalhos/Rodapés Manual HTML/CSS
Marcas d'água Código manual Embutido
Mesclar PDFs Limitado Sim
Dividir PDFs Limitado Sim
Assinaturas digitais Não Sim
PDF/A Não Sim
Simplicidade e facilidade de uso Moderado Alto

Guia rápido: Migração do ZetPDF para o IronPDF

A migração pode começar imediatamente com esses passos fundamentais.

Passo 1: Substitua o pacote NuGet

Remover ZetPDF:

# Remove ZetPDF
dotnet remove package ZetPDF
# Remove ZetPDF
dotnet remove package ZetPDF
SHELL

Instale o IronPDF:

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Etapa 2: Atualizar Namespaces

Substitua os namespaces do ZetPDF pelo namespace do IronPDF :

// Before (ZetPDF)
using ZetPdf;
using ZetPdf.Drawing;
using ZetPdf.Fonts;

// After (IronPDF)
using IronPdf;
// Before (ZetPDF)
using ZetPdf;
using ZetPdf.Drawing;
using ZetPdf.Fonts;

// After (IronPDF)
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Etapa 3: Inicializar a licença

Adicionar inicialização de licença na inicialização do aplicativo:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Exemplos de migração de código

Converter HTML para PDF

A operação de conversão de HTML para PDF demonstra as diferenças de API entre essas bibliotecas PDF do .NET .

Abordagem ZetPDF:

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

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// NuGet: Install-Package ZetPDF
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
Imports ZetPDF
Imports System

Module Program
    Sub Main()
        Dim converter As New HtmlToPdfConverter()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

Abordagem IronPDF :

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var 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();
        var 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

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim htmlContent = "<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 Class
$vbLabelText   $csharpLabel

O ZetPDF usa HtmlToPdfConverter com ConvertHtmlToPdf() que escreve diretamente em um caminho de arquivo. O IronPDF fornece ChromePdfRenderer com RenderHtmlAsPdf() que retorna um objeto PdfDocument, oferecendo mais flexibilidade com a saída — você pode salvar em arquivo, obter dados binários ou realizar operações adicionais antes de salvar.

Para cenários avançados de conversão de HTML para PDF, consulte o guia de conversão de HTML para PDF .

Converter URLs em PDF

A conversão de URL para PDF mostra claramente as diferenças nos padrões.

Abordagem ZetPDF:

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

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
// NuGet: Install-Package ZetPDF
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
Imports ZetPDF
Imports System

Module Program
    Sub Main()
        Dim converter As New HtmlToPdfConverter()
        Dim url As String = "https://www.example.com"
        converter.ConvertUrlToPdf(url, "webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

Abordagem IronPDF :

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var 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 = "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

ZetPDF usa a mesma classe HtmlToPdfConverter que ConvertUrlToPdf(). O IronPDF fornece RenderUrlAsPdf() em ChromePdfRenderer, que utiliza um mecanismo de renderização Chromium completo para captura precisa de páginas da web, incluindo execução de JavaScript e CSS moderno.

Consulte a documentação sobre URLs para PDF para obter informações sobre autenticação e opções de cabeçalho personalizadas.

Unir vários PDFs

A fusão de PDFs revela diferenças significativas na API de como os documentos são tratados.

Abordagem ZetPDF:

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

class Program
{
    static void Main()
    {
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
// NuGet: Install-Package ZetPDF
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
Imports ZetPDF
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim merger As New PdfMerger()
        Dim files As New List(Of String) From {"document1.pdf", "document2.pdf"}
        merger.MergeFiles(files, "merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

Abordagem IronPDF :

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

class Program
{
    static void Main()
    {
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim pdfs As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        }
        Dim merged = PdfDocument.Merge(pdfs)
        merged.SaveAs("merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

O ZetPDF usa uma classe dedicada PdfMerger que opera em caminhos de arquivo com MergeFiles(). O IronPDF carrega documentos como objetos PdfDocument usando PdfDocument.FromFile(), e então os mescla com o método estático PdfDocument.Merge(). Essa abordagem orientada a objetos permite operações adicionais no documento mesclado antes de salvá-lo.

Consulte a documentação sobre mesclagem de PDFs para obter opções adicionais de mesclagem.

Desenho baseado em coordenadas versus HTML

Para desenvolvedores que já possuem código ZetPDF usando gráficos baseados em coordenadas, o processo de migração envolve a conversão dos comandos de desenho para HTML/CSS.

Abordagem ZetPDF baseada em coordenadas:

using ZetPdf;
using ZetPdf.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Width = XUnit.FromMillimeter(210);
page.Height = XUnit.FromMillimeter(297);

var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");
using ZetPdf;
using ZetPdf.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Width = XUnit.FromMillimeter(210);
page.Height = XUnit.FromMillimeter(297);

var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");
Imports ZetPdf
Imports ZetPdf.Drawing

Dim document As New PdfDocument()
Dim page = document.AddPage()
page.Width = XUnit.FromMillimeter(210)
page.Height = XUnit.FromMillimeter(297)

Dim graphics = XGraphics.FromPdfPage(page)
Dim titleFont As New XFont("Arial", 24, XFontStyle.Bold)
Dim bodyFont As New XFont("Arial", 12)

graphics.DrawString("Company Report", titleFont, XBrushes.Navy, New XPoint(50, 50))
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black, New XPoint(50, 80))
graphics.DrawString("Generated: " & DateTime.Now.ToString(), bodyFont, XBrushes.Gray, New XPoint(50, 100))

document.Save("report.pdf")
$vbLabelText   $csharpLabel

Abordagem HTML do IronPDF :

using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; padding: 50px; }}
        h1 {{ color: navy; }}
        .date {{ color: gray; }}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; padding: 50px; }}
        h1 {{ color: navy; }}
        .date {{ color: gray; }}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
Imports IronPdf

Dim html As String = $"
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; padding: 50px; }}
        h1 {{ color: navy; }}
        .date {{ color: gray; }}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

A abordagem ZetPDF exige a criação de objetos de fonte, o cálculo das posições exatas dos pixels e o gerenciamento manual do contexto gráfico. A abordagem do IronPDF utiliza HTML e CSS padrão que os desenvolvedores web já conhecem — fontes, cores e layout são gerenciados por meio de propriedades CSS familiares.

Referência de mapeamento da API ZetPDF para IronPDF

Este mapeamento acelera a migração ao mostrar equivalentes diretos da API:

ZetPDF IronPDF
new PdfDocument() new ChromePdfRenderer()
document.AddPage() Automático
XGraphics.FromPdfPage(page) N / D
graphics.DrawString() Elementos de texto HTML
graphics.DrawImage() <img> tag
graphics.DrawLine() Bordas CSS
graphics.DrawRectangle() CSS border + div
new XFont() CSS font-family
XBrushes.Black CSS color
document.Save() pdf.SaveAs()
PdfReader.Open() PdfDocument.FromFile()
HtmlToPdfConverter ChromePdfRenderer
ConvertHtmlToPdf() RenderHtmlAsPdf()
ConvertUrlToPdf() RenderUrlAsPdf()
PdfMerger PdfDocument.Merge()

Problemas e soluções comuns em migrações

Problema 1: Layout baseado em coordenadas

ZetPDF: Tudo requer coordenadas X,Y exatas com posicionamento manual.

Solução: Utilize um layout de fluxo HTML/CSS. Para posicionamento absoluto quando necessário, use CSS:

.positioned-element {
    position: absolute;
    top: 100px;
    left: 50px;
}

Problema 2: Gerenciamento de Objetos de Fonte

ZetPDF: Crie objetos XFont para cada variação de fonte.

Solução: Use CSS font-family — as fontes são gerenciadas automaticamente:

<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; font-weight: bold; }
</style>
<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; font-weight: bold; }
</style>
HTML

Edição 3: Manipulação de Cores

ZetPDF: Use XBrushes e objetos de cor.

Solução: Utilize cores CSS padrão:

.header { color: navy; background-color: #f5f5f5; }
.warning { color: rgb(255, 0, 0); }

Edição 4: Quebras de página manuais

ZetPDF: Monitore a posição Y e crie novas páginas manualmente quando o conteúdo exceder os limites.

Solução: O IronPDF lida com quebras de página automáticas. Para controle explícito, use CSS:

.section { page-break-after: always; }
.keep-together { page-break-inside: avoid; }

Problema 5: Criação de tabela

ZetPDF: Requer desenho manual de retângulos, linhas e posicionamento de texto.

Solução: Utilize tabelas HTML padrão com estilização CSS:

<table style="border-collapse: collapse; width: 100%;">
    <tr>
        <th style="border: 1px solid black; padding: 8px;">Header</th>
    </tr>
    <tr>
        <td style="border: 1px solid black; padding: 8px;">Data</td>
    </tr>
</table>
<table style="border-collapse: collapse; width: 100%;">
    <tr>
        <th style="border: 1px solid black; padding: 8px;">Header</th>
    </tr>
    <tr>
        <td style="border: 1px solid black; padding: 8px;">Data</td>
    </tr>
</table>
HTML

Lista de verificação para migração do ZetPDF

Tarefas pré-migração

Faça uma auditoria em seu código-fonte para identificar todos os usos do ZetPDF:

grep -r "using ZetPDF" --include="*.cs" .
grep -r "HtmlToPdfConverter\|PdfMerger\|XGraphics" --include="*.cs" .
grep -r "using ZetPDF" --include="*.cs" .
grep -r "HtmlToPdfConverter\|PdfMerger\|XGraphics" --include="*.cs" .
SHELL

Documento com código de desenho baseado em coordenadas que precisa ser convertido para HTML. Observe os padrões de uso de fontes e cores. Mapear estruturas de layout para seus equivalentes em HTML.

Tarefas de atualização de código

  1. Remova o pacote NuGet ZetPDF
  2. Instale o pacote NuGet IronPDF
  3. Atualize as importações de namespace de ZetPDF para IronPdf
  4. Substitua HtmlToPdfConverter por ChromePdfRenderer
  5. Converter chamadas ConvertHtmlToPdf() para RenderHtmlAsPdf() + SaveAs()
  6. Converter chamadas ConvertUrlToPdf() para RenderUrlAsPdf() + SaveAs()
  7. Substitua PdfMerger.MergeFiles() por PdfDocument.Merge()
  8. Converter chamadas DrawString() em elementos de texto HTML
  9. Converter XFont para CSS font-family
  10. Substitua XBrushes por cores CSS.
  11. Adicionar inicialização da licença do IronPDF na inicialização do sistema.

Testes pós-migração

Após a migração, verifique os seguintes aspectos:

  • Compare a saída visual para garantir que a aparência corresponda ou seja melhorada.
  • Verifique se as fontes são renderizadas conforme o esperado com o estilo CSS.
  • As quebras de página de teste ocorrem corretamente com a paginação automática.
  • Verifique se as imagens estão posicionadas e exibidas corretamente.
  • Testar se as operações de mesclagem de PDFs produzem resultados corretos
  • Confirme se todas as funcionalidades existentes funcionam com a nova implementação.

Principais benefícios da migração para o IronPDF

A migração do ZetPDF para o IronPDF oferece diversas vantagens cruciais:

Mecanismo de renderização Chromium moderno: O IronPDF usa o Chromium para conversão de HTML em PDF, garantindo suporte completo a CSS3 e JavaScript ES2024. Os frameworks modernos e os designs responsivos são exibidos corretamente.

Criação de conteúdo baseado em HTML: os desenvolvedores web podem aproveitar suas habilidades existentes em HTML e CSS. Não é necessário aprender APIs de desenho baseadas em coordenadas nem gerenciar objetos de fonte.

Layout e paginação automáticos: a quebra de texto, as quebras de página e o layout fluido acontecem automaticamente. Não é necessário calcular manualmente as posições dos elementos.

API simplificada: Chamadas de método único para operações comuns. PdfDocument.Merge() substitui padrões complexos de manipulação de caminhos de arquivos.

Desenvolvimento ativo: À medida que a adoção do .NET 10 e do C# 14 aumenta até 2026, as atualizações regulares do IronPDF garantem a compatibilidade com as versões atuais e futuras do .NET .

Conjunto completo de recursos: marca d'água integrada, assinaturas digitais, conformidade com PDF/A e recursos avançados de manipulação de PDF que o ZetPDF não possui.

Curtis Chau
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 ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim