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

Como migrar do XFINIUM.PDF para o IronPDF em C#

Curtis Chau
Curtis Chau
Atualizado:

XFINIUM.PDF é uma biblioteca PDF multiplataforma que oferece ferramentas abrangentes para criar e editar PDFs programaticamente em C#. Embora ofereça duas edições — Generator e Viewer — a dependência da biblioteca em programação gráfica baseada em coordenadas cria desafios significativos para equipes de desenvolvimento que criam aplicativos com grande volume de documentos. Cada elemento precisa ser posicionado manualmente usando coordenadas de pixel, transformando o que deveriam ser documentos simples em exercícios complexos de desenho.

Este guia fornece um caminho completo de migração do XFINIUM.PDF 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 XFINIUM.PDF

XFINIUM.PDF é uma biblioteca PDF de baixo nível que depende de programação gráfica baseada em coordenadas, obrigando os desenvolvedores a posicionar manualmente cada elemento na página. Essa abordagem se torna um pesadelo de manutenção à medida que os requisitos mudam. Os principais motivos pelos quais as equipes de desenvolvimento consideram a migração incluem:

Sem suporte a HTML: XFINIUM.PDF não consegue converter HTML/CSS diretamente para PDF. O foco é a criação programática de PDFs usando primitivas de desenho de baixo nível, o que pode não ser suficiente para projetos que exigem amplas funcionalidades de conversão de HTML para PDF.

API baseada em coordenadas: O posicionamento manual com coordenadas de pixel, como DrawString("text", font, brush, 50, 100), é necessário para cada elemento na página.

Gerenciamento manual de fontes: os objetos de fonte devem ser criados e gerenciados explicitamente usando classes como PdfStandardFont e PdfBrush.

Sem suporte para estilos CSS: Não há compatibilidade com estilos modernos da web. Cores, fontes e layouts devem ser tratados manualmente por meio de chamadas de métodos programáticos.

Sem renderização de JavaScript : somente conteúdo estático. O XFINIUM.PDF não consegue renderizar conteúdo web dinâmico nem executar JavaScript.

Formatação de texto complexa: Para textos que vão além de uma única linha, são necessários cálculos manuais de medição e quebra de texto.

Recursos limitados da comunidade: Há uma carência de recursos fornecidos pela comunidade, como exemplos e tutoriais, em comparação com as soluções mais populares, o que pode dificultar o início para novos usuários.

O problema central: API gráfica versus HTML

O XFINIUM.PDF força você a pensar como um programador gráfico, não como um designer de documentos:

// XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50);
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80);
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80);
// ... hundreds of lines for a simple document
// XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50);
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80);
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80);
// ... hundreds of lines for a simple document
' XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50)
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80)
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80)
' ... hundreds of lines for a simple document
$vbLabelText   $csharpLabel

O IronPDF utiliza HTML/CSS familiar:

// IronPDF: Declarative HTML
var html = @"<h1>Invoice</h1><p><b>Customer:</b> " + customer.Name + "</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
// IronPDF: Declarative HTML
var html = @"<h1>Invoice</h1><p><b>Customer:</b> " + customer.Name + "</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
' IronPDF: Declarative HTML
Dim html As String = "<h1>Invoice</h1><p><b>Customer:</b> " & customer.Name & "</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

IronPDF vs XFINIUM.PDF: 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 XFINIUM.PDF IronPDF
HTML para PDF Suporte limitado a HTML, com foco na criação programática de PDFs. Conversão completa de HTML para PDF com suporte abrangente.
Comunidade e Apoio Comunidade menor, menos recursos online disponíveis. Comunidade ampla com extensa documentação e tutoriais.
Licença Comercial com licenciamento baseado no desenvolvedor Comercial
Suporte multiplataforma Fortes capacidades multiplataforma Também suporta operações multiplataforma
Suporte a CSS Não CSS3 completo
JavaScript Não ES2024 completo
Flexbox/Grade Não Sim
Layout automático Não Sim
Quebras de página automáticas Não Sim
Posicionamento manual Obrigatório Opcional (posicionamento CSS)
Curva de Aprendizagem Alto (sistema de coordenadas) Baixo (HTML/CSS)
Verbosidade do código Muito alto Baixo

Guia rápido: Migração de XFINIUM.PDF para IronPDF

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

Passo 1: Substitua o pacote NuGet

Remover XFINIUM.PDF:

# Remove XFINIUM.PDF
dotnet remove package Xfinium.Pdf
# Remove XFINIUM.PDF
dotnet remove package Xfinium.Pdf
SHELL

Instale o IronPDF:

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

Etapa 2: Atualizar Namespaces

Substitua os namespaces XFINIUM.PDF pelo namespace IronPDF :

// Before (XFINIUM.PDF)
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Content;
using Xfinium.Pdf.FlowDocument;

// After (IronPDF)
using IronPdf;
// Before (XFINIUM.PDF)
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Content;
using Xfinium.Pdf.FlowDocument;

// 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 mais fundamental revela a diferença de complexidade entre essas bibliotecas PDF do .NET .

Abordagem XFINIUM.PDF:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Actions;
using Xfinium.Pdf.FlowDocument;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfFlowDocument flowDocument = new PdfFlowDocument();

        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        PdfFlowContent content = new PdfFlowContent();
        content.AppendHtml(html);
        flowDocument.AddContent(content);

        flowDocument.RenderDocument(document);
        document.Save("output.pdf");
    }
}
// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Actions;
using Xfinium.Pdf.FlowDocument;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfFlowDocument flowDocument = new PdfFlowDocument();

        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        PdfFlowContent content = new PdfFlowContent();
        content.AppendHtml(html);
        flowDocument.AddContent(content);

        flowDocument.RenderDocument(document);
        document.Save("output.pdf");
    }
}
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Actions
Imports Xfinium.Pdf.FlowDocument
Imports System.IO

Module Program
    Sub Main()
        Dim document As New PdfFixedDocument()
        Dim flowDocument As New PdfFlowDocument()

        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

        Dim content As New PdfFlowContent()
        content.AppendHtml(html)
        flowDocument.AddContent(content)

        flowDocument.RenderDocument(document)
        document.Save("output.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Abordagem IronPDF :

// NuGet: Install-Package IronPdf
using IronPdf;

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

        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 = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

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

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

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

XFINIUM.PDF requer a criação de um objeto PdfFixedDocument, um objeto PdfFlowDocument, a chamada de AppendHtml(), a adição de conteúdo ao documento de fluxo, a renderização no documento fixo e, finalmente, o salvamento. O IronPDF simplifica isso para três linhas: criar um renderizador, renderizar o HTML e salvar.

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

Unir vários PDFs

A fusão de PDFs demonstra claramente as diferenças na complexidade da API.

Abordagem XFINIUM.PDF:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument output = new PdfFixedDocument();

        FileStream file1 = File.OpenRead("document1.pdf");
        PdfFixedDocument pdf1 = new PdfFixedDocument(file1);

        FileStream file2 = File.OpenRead("document2.pdf");
        PdfFixedDocument pdf2 = new PdfFixedDocument(file2);

        for (int i = 0; i < pdf1.Pages.Count; i++)
        {
            output.Pages.Add(pdf1.Pages[i]);
        }

        for (int i = 0; i < pdf2.Pages.Count; i++)
        {
            output.Pages.Add(pdf2.Pages[i]);
        }

        output.Save("merged.pdf");

        file1.Close();
        file2.Close();
    }
}
// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument output = new PdfFixedDocument();

        FileStream file1 = File.OpenRead("document1.pdf");
        PdfFixedDocument pdf1 = new PdfFixedDocument(file1);

        FileStream file2 = File.OpenRead("document2.pdf");
        PdfFixedDocument pdf2 = new PdfFixedDocument(file2);

        for (int i = 0; i < pdf1.Pages.Count; i++)
        {
            output.Pages.Add(pdf1.Pages[i]);
        }

        for (int i = 0; i < pdf2.Pages.Count; i++)
        {
            output.Pages.Add(pdf2.Pages[i]);
        }

        output.Save("merged.pdf");

        file1.Close();
        file2.Close();
    }
}
Imports Xfinium.Pdf
Imports System.IO

Module Program
    Sub Main()
        Dim output As New PdfFixedDocument()

        Dim file1 As FileStream = File.OpenRead("document1.pdf")
        Dim pdf1 As New PdfFixedDocument(file1)

        Dim file2 As FileStream = File.OpenRead("document2.pdf")
        Dim pdf2 As New PdfFixedDocument(file2)

        For i As Integer = 0 To pdf1.Pages.Count - 1
            output.Pages.Add(pdf1.Pages(i))
        Next

        For i As Integer = 0 To pdf2.Pages.Count - 1
            output.Pages.Add(pdf2.Pages(i))
        Next

        output.Save("merged.pdf")

        file1.Close()
        file2.Close()
    End Sub
End Module
$vbLabelText   $csharpLabel

Abordagem IronPDF :

// NuGet: Install-Package IronPdf
using IronPdf;
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");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
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");
    }
}
Imports IronPdf
Imports System.Collections.Generic

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

        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

O XFINIUM.PDF exige a criação de um documento de saída, a abertura de fluxos de arquivos, o carregamento de cada documento, a iteração manual pelas páginas e a adição delas uma a uma, o salvamento e, em seguida, o fechamento dos fluxos. O IronPDF fornece um único método PdfDocument.Merge() que lida com toda a complexidade internamente.

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

Criando PDFs com texto e imagens

Documentos com conteúdo misto demonstram a diferença paradigmática fundamental.

Abordagem XFINIUM.PDF:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Core;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfPage page = document.Pages.Add();

        PdfStandardFont font = new PdfStandardFont(PdfStandardFontFace.Helvetica, 24);
        PdfBrush brush = new PdfBrush(PdfRgbColor.Black);

        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50);

        FileStream imageStream = File.OpenRead("image.jpg");
        PdfJpegImage image = new PdfJpegImage(imageStream);
        page.Graphics.DrawImage(image, 50, 100, 200, 150);
        imageStream.Close();

        document.Save("output.pdf");
    }
}
// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Core;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfPage page = document.Pages.Add();

        PdfStandardFont font = new PdfStandardFont(PdfStandardFontFace.Helvetica, 24);
        PdfBrush brush = new PdfBrush(PdfRgbColor.Black);

        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50);

        FileStream imageStream = File.OpenRead("image.jpg");
        PdfJpegImage image = new PdfJpegImage(imageStream);
        page.Graphics.DrawImage(image, 50, 100, 200, 150);
        imageStream.Close();

        document.Save("output.pdf");
    }
}
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Graphics
Imports Xfinium.Pdf.Core
Imports System.IO

Class Program
    Shared Sub Main()
        Dim document As New PdfFixedDocument()
        Dim page As PdfPage = document.Pages.Add()

        Dim font As New PdfStandardFont(PdfStandardFontFace.Helvetica, 24)
        Dim brush As New PdfBrush(PdfRgbColor.Black)

        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50)

        Dim imageStream As FileStream = File.OpenRead("image.jpg")
        Dim image As New PdfJpegImage(imageStream)
        page.Graphics.DrawImage(image, 50, 100, 200, 150)
        imageStream.Close()

        document.Save("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Abordagem IronPDF :

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

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

        string imageBase64 = Convert.ToBase64String(File.ReadAllBytes("image.jpg"));
        string html = $@"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

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

        string imageBase64 = Convert.ToBase64String(File.ReadAllBytes("image.jpg"));
        string html = $@"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System.IO

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

        Dim imageBase64 As String = Convert.ToBase64String(File.ReadAllBytes("image.jpg"))
        Dim html As String = $"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>"

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

O XFINIUM.PDF requer a criação de um documento, a adição de uma página, a criação de objetos de fonte e pincel, o desenho de texto em coordenadas específicas, a abertura de um fluxo de imagem, a criação de um PdfJpegImage, o desenho da imagem em coordenadas com dimensões, o fechamento do fluxo e o salvamento. O IronPDF utiliza HTML padrão com imagens em base64 incorporadas — a mesma abordagem que os desenvolvedores web usam diariamente.

Referência de mapeamento da API XFINIUM.PDF para o IronPDF

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

XFINIUM.PDF IronPDF
PdfFixedDocument ChromePdfRenderer
PdfPage Automático
page.Graphics.DrawString() Elementos de texto HTML
page.Graphics.DrawImage() <img> tag
page.Graphics.DrawLine() CSS border ou <hr>
page.Graphics.DrawRectangle() CSS border em <div>
PdfStandardFont CSS font-family
PdfRgbColor CSS color
PdfBrush Propriedades CSS
PdfJpegImage <img> tag com base64
document.Save(stream) pdf.SaveAs() ou pdf.BinaryData
PdfFlowDocument RenderHtmlAsPdf()
PdfFlowContent.AppendHtml() RenderHtmlAsPdf()

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

Problema 1: Layout baseado em coordenadas

XFINIUM.PDF: 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

XFINIUM.PDF: Crie objetos PdfStandardFont ou PdfUnicodeTrueTypeFont para cada 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; }
</style>
<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; }
</style>
HTML

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

XFINIUM.PDF: Crie objetos PdfRgbColor e PdfBrush para cores.

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

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

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

XFINIUM.PDF: 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: Carregamento de imagens

XFINIUM.PDF: Abrir fluxos de arquivos, criar objetos PdfJpegImage, desenhar em coordenadas, fechar fluxos.

Solução: Utilize tags HTML <img> com caminhos de arquivos ou dados em base64:

<img src="image.jpg" width="200" height="150" />

<img src="data:image/jpeg;base64,..." />
<img src="image.jpg" width="200" height="150" />

<img src="data:image/jpeg;base64,..." />
HTML

Lista de verificação de migração XFINIUM.PDF

Tarefas pré-migração

Faça uma auditoria no seu código-fonte para identificar todos os usos de XFINIUM.PDF:

grep -r "using Xfinium.Pdf" --include="*.cs" .
grep -r "Graphics.DrawString\|Graphics.DrawImage\|Graphics.DrawLine" --include="*.cs" .
grep -r "using Xfinium.Pdf" --include="*.cs" .
grep -r "Graphics.DrawString\|Graphics.DrawImage\|Graphics.DrawLine" --include="*.cs" .
SHELL

Documente os layouts baseados em coordenadas e anote todos os valores de posicionamento X,Y. Identificar objetos de fonte e cor (PdfStandardFont, PdfRgbColor, PdfBrush). Fluxos de trabalho de PDF mesclados em mapas usando PdfFixedDocument.Pages.Add().

Tarefas de atualização de código

  1. Remova o pacote NuGet Xfinium.Pdf.
  2. Instale o pacote NuGet IronPDF
  3. Atualizar as importações de namespace de Xfinium.Pdf para IronPdf
  4. Converter chamadas DrawString() em elementos de texto HTML
  5. Converter chamadas DrawImage() em tags HTML <img>
  6. Converter DrawRectangle() e DrawLine() em bordas CSS
  7. Substitua PdfStandardFont por CSS font-family
  8. Substitua PdfRgbColor e PdfBrush por cores CSS.
  9. Substituir a mesclagem de loops de página por PdfDocument.Merge()
  10. 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 às expectativas.
  • Verificar a renderização do texto com a nova abordagem HTML/CSS
  • Verificar o posicionamento da imagem usando CSS
  • As quebras de página de teste ocorrem conforme o esperado.
  • Verifique se as configurações de segurança do PDF estão aplicadas corretamente.
  • Testar em todas as plataformas alvo

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

A migração do XFINIUM.PDF para o IronPDF oferece diversas vantagens importantes:

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 e pincel.

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

Suporte a CSS moderno: CSS3 completo, incluindo layouts Flexbox e Grid. Os designs responsivos são convertidos diretamente para PDF.

Operações simplificadas em PDF: Chamadas de método único para operações comuns como PdfDocument.Merge() substituem loops complexos de iteração de página.

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 .

Documentação extensa: Grande comunidade com documentação abrangente, tutoriais e recursos de suporte, em comparação com o ecossistema menor do XFINIUM.PDF.

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