COMPARAçãO

Como escolher a melhor biblioteca C# para geração de documentos em 2026

Atualizado:

Selecionar uma biblioteca PDF C# afeta a exposição do licenciamento do seu projeto, a flexibilidade de implantação e o custo de manutenção a longo prazo. A maioria das bibliotecas que parecem adequadas durante a avaliação revelam limitações em produção — requisitos AGPL que você não esperava, renderização de HTML que não corresponde ao seu navegador, ou vazamentos de memória que só surgem no Linux.

Este artigo compara as principais opções com exemplos de código, documenta os compromissos que importam na prática e inclui uma comparação de código lado a lado gerando a mesma fatura em três bibliotecas diferentes para que você possa ver as diferenças na API diretamente.

Introdução Rápida: HTML para PDF em Três Linhas

Instale via NuGet:

Install-Package IronPDF

Gerar um PDF:

using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
pdf.SaveAs("output.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
pdf.SaveAs("output.pdf");
$vbLabelText   $csharpLabel

Isso funciona no Windows, Linux, macOS e Docker sem configuração adicional. A saída corresponde ao Chrome porque oIronPDFincorpora o mesmo motor de renderização do Chromium.

Critérios de Avaliação

Antes de comparar bibliotecas, saiba o que avaliar. Estas são as perguntas que surgem problemas de produção cedo:

Critério O que Testar Por Que Importa
Renderização HTML/CSS Alimente com seus modelos reais com Flexbox/Grid A maioria das bibliotecas afirma ter suporte a HTML, mas renderiza no máximo CSS 2.1
Execução de JavaScript Teste com Chart.js ou conteúdo de tabela dinâmica Bibliotecas sem suporte a JS produzem seções em branco
Modelo de licenciamento Leia a licença completa, não o resumo AGPL requer abrir o código-fonte de toda a sua aplicação
Suporte a plataforma Implante no seu ambiente alvo Linux/Docker/ARM64 Sucesso no Windows não prevê comportamento no Linux
Memória sob carga Gere 100+ documentos em um loop Testes com um único documento ocultam vazamentos que travam servidores em produção
Preço publicado Verifique se o preço está no site "Contact sales" geralmente significa $15K–$210K/ano

Comparação de Bibliotecas

IronPDF— Chromium Embutido, Suporte Completo a CSS/JS

IronPDF embute o Chromium diretamente no pacote NuGet. A renderização de HTML corresponde ao Chrome porque é o motor do Chrome. CSS Flexbox, Grid, propriedades personalizadas eJavaScriptsão todos executados como esperado.

using IronPdf;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
    <head>
        <style>
            .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; }
            .card { background: linear-gradient(135deg, #f8fafc, #e2e8f0);
                    border-radius: 8px; padding: 20px; text-align: center; }
        </style>
    </head>
    <body>
        <div class='grid'>
            <div class='card'><h3>Revenue</h3><p>$1.2M</p></div>
            <div class='card'><h3>Users</h3><p>45,230</p></div>
            <div class='card'><h3>Uptime</h3><p>99.97%</p></div>
        </div>
    </body>
    </html>");
pdf.SaveAs("dashboard.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
    <head>
        <style>
            .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; }
            .card { background: linear-gradient(135deg, #f8fafc, #e2e8f0);
                    border-radius: 8px; padding: 20px; text-align: center; }
        </style>
    </head>
    <body>
        <div class='grid'>
            <div class='card'><h3>Revenue</h3><p>$1.2M</p></div>
            <div class='card'><h3>Users</h3><p>45,230</p></div>
            <div class='card'><h3>Uptime</h3><p>99.97%</p></div>
        </div>
    </body>
    </html>");
pdf.SaveAs("dashboard.pdf");
$vbLabelText   $csharpLabel

Trade-offs a considerar: O Chromium embutido adiciona ~200MB ao pacote de implantação. Para implantações padrão em servidor e container, este é um download único sem impacto em tempo de execução. Para ambientes com restrição de tamanho, como o plano de consumo do Azure Functions, verifique o limite de tamanho de implantação. A primeira geração de PDF em um processo frio leva de 2 a 5 segundos para a inicialização do Chromium; as gerações subsequentes são executadas em 100–500ms. A linha de base de memória é de ~150–200MB — planeje os recursos do container de acordo.

Licenciamento: Licenças perpétuas começando em $749 (1 desenvolvedor). Preços publicados em ironpdf.com. Sem taxas por documento, sem AGPL, sem limites de receita.

iText 7(iTextSharp) — Licenciamento AGPL, HTML Limitado

iText é uma biblioteca de manipulação de PDF capaz com uma longa história. O complemento pdfHTML fornece conversão de HTML para PDF, mas não usa um motor de navegador — ele aproxima o CSS 2.1 com um analisador personalizado.

Uma equipe de produção em uma empresa SaaS de médio porte descobriu isso quando migraram seus modelos de fatura de visualizações Razor. Os modelos usavam CSS Flexbox para layouts de coluna responsivos. Após integrar o pdfHTML do iText, cada fatura ficou renderizada como uma pilha vertical de coluna única. As propriedades display: flex, gap e justify-content foram silenciosamente ignoradas. Três semanas de tempo de desenvolvimento foram gastas antes que a equipe percebesse que o pdfHTML não poderia renderizar seus CSS existentes.

A realidade AGPL: iText usa a licença AGPL. Se o seu aplicativo estiver acessível pela rede — o que inclui todos os aplicativos web, APIs e produtos SaaS — você deve liberar o código-fonte de todo o seu aplicativo sob a AGPL. Não apenas o módulo PDF. Tudo. O iText e a empresa-mãe Apryse aplicam isso ativamente.

Licenciamento comercial: iText transicionou para licenciamento baseado em assinatura em 2024. Os preços não são publicados — você deve contatar o departamento de vendas para obter uma cotação. Dados de terceiros sugerem de $15.000 a $210.000 anuais, dependendo do volume de uso.

PdfSharp— Licença MIT, Sem HTML

PdfSharp é genuinamente gratuito sob a licença MIT com 34,9 milhões de downloads no NuGet. A contrapartida é a capacidade: ele fornece uma API de desenho baseada em coordenadas sem analisador de HTML, sem motor de CSS e sem sistema de modelos.

Uma equipe construindo um painel de relatórios escolheu PdfSharp porque era gratuito e bem conhecido. Eles passaram quatro meses escrevendo código de layout baseado em coordenadas — calculando posições X/Y para cada elemento de texto, desenhando bordas de tabelas pixel a pixel, lidando manualmente com quebras de páginas. Quando eles finalmente compararam a saída deles com o que o mesmo modelo HTML produziu em um navegador, perceberam que tinham construído uma versão pior do que uma biblioteca baseada em Chromium faz automaticamente.

PdfSharp funciona bem para mesclar PDFs, adicionar marcas d'água e construir documentos estruturados simples a partir de dados. Se você não precisa renderizar HTML, ela continua sendo uma opção legítima.

QuestPDF— API Elegante, Sem HTML, Limite de Receita

QuestPDF oferece uma API C# fluente para criar documentos programaticamente. O design da API é genuinamente bom — é uma das melhores APIs de biblioteca .NET em qualquer categoria.

Duas restrições importam:QuestPDFnão renderiza HTML (por design — esta é uma escolha arquitetônica deliberada, não uma funcionalidade ausente), e a Licença Comunitária cobre empresas com receita bruta anual abaixo de $1 milhão. Uma vez que sua empresa ultrapasse esse limite, uma licença comercial torna-se obrigatória. Empresas se aproximando do limite devem prever essa transição antes que ela se torne urgente.

Apesar do posicionamento claro daQuestPDFcontra HTML, desenvolvedores regularmente descobrem isso após iniciarem a implementação porque a biblioteca aparece em resultados de busca por "C# PDF library" ao lado de bibliotecas capazes de HTML.

Wrappers dowkhtmltopdf— Abandonado, CVEs Não Corrigidos

A época dowkhtmltopdfpassou. A organização GitHub foi arquivada em julho de 2024. O motor subjacente QtWebKit foi descontinuado pelo Qt em 2015. CVEs conhecidos — incluindo CVE-2022-35583 (CVSS 9.8, SSRF que possibilita exfiltração de credenciais da AWS) — nunca serão corrigidos.

Wrappers C# como DinkToPdf, NReco.PdfGenerator e WkHtmlToXSharp todos encapsulam o mesmo binário abandonado. O motor de renderização está congelado em aproximadamente a capacidade do Safari 2011: sem Flexbox, sem Grid,JavaScriptlimitado. Esta não é uma opção viável para novos projetos.

Puppeteer Sharp— Renderização Completa, Complexidade Operacional

Puppeteer Sharp controla o Chrome sem cabeça por meio de bindings .NET. A qualidade de renderização corresponde ao Chrome porque ele é o Chrome. A contrapartida é operacional: você gerencia processos de navegador externos, incluindo downloads, pooling, monitoramento de memória e recuperação de falhas.

using PuppeteerSharp;

// Downloads ~280MB Chromium on first run
await new BrowserFetcher().DownloadAsync();

await using var browser = await Puppeteer.LaunchAsync(
    new LaunchOptions { Headless = true });
await using var page = await browser.NewPageAsync();
await page.SetContentAsync(html);
return await page.PdfAsync(new PdfOptions { Format = PaperFormat.A4, PrintBackground = true });
using PuppeteerSharp;

// Downloads ~280MB Chromium on first run
await new BrowserFetcher().DownloadAsync();

await using var browser = await Puppeteer.LaunchAsync(
    new LaunchOptions { Headless = true });
await using var page = await browser.NewPageAsync();
await page.SetContentAsync(html);
return await page.PdfAsync(new PdfOptions { Format = PaperFormat.A4, PrintBackground = true });
$vbLabelText   $csharpLabel

Em produção, você também precisa de pooling de processos de navegador, monitoramento de vazamento de memória (processos do Chromium podem vazar), recuperação de falhas e limpeza de recursos. O deployment com Docker requer a instalação de dependências do Chromium — um Dockerfile substancial em comparação a uma imagem .NET padrão.Puppeteer Sharpé viável se sua equipe puder absorver a sobrecarga operacional.

Aspose.PDF — Funcionalidades Extensas, Problemas de Memória no Linux

Aspose.PDF oferece ampla funcionalidade de PDF com boa documentação. O problema significativo é a estabilidade no Linux:Asposedepende do System.Drawing.Common, que requer libgdiplus no Linux — uma biblioteca não mantida com vazamentos de memória documentados. Relatos de desenvolvedores se estendem por anos:

"Várias dezenas de solicitações fazem o serviço ficar sem memória no ambiente Unix, mas isso não ocorre no ambiente baseado em Windows" — Fórum Aspose, março de 2022

Para implementações apenas em Windows,Asposecontinua capaz. Para implantações multiplataforma ou containerizadas, a dependência System.Drawing.Common cria um risco contínuo. O licenciamento comercial começa em aproximadamente $999 por desenvolvedor.

Comparação de recursos

Recurso IronPDF iText 7 PdfSharp QuestPDF wkhtmltopdf Puppeteer Aspose
HTML para PDF Completo (Chromium) Limitado (CSS 2.1) Não Não Descontinuado Completo (Chrome) Limitado
CSS Flexbox/Grid Sim Não Não Não Não Sim Não
JavaScript Sim Não Não Não Limitado Sim Não
Linux (sem libgdiplus) Sim Sim Parcial* Sim N / D Sim Não
Implantação em Docker Imagem padrão .NET Padrão Parcial* Padrão Complexo Complexo Requer libgdiplus
Manutenção ativa Sim Sim Sim Sim Abandonado Sim Sim
Preço publicado Sim ($749+) Não ($15K–$210K/ano) Grátis (MIT) Sim (grátis <$1M) Livre Grátis (MIT) Sim ($999+)
Licença perpétua Sim Não (assinatura) N / D N / D N / D N / D Sim
Livre de AGPL Sim Não (requer comercial) Sim Sim Sim Sim Sim

*PdfSharp tem problemas específicos documentados de plataforma com algumas configurações.

Comparação de desempenho

Testado em uma VM na nuvem de nível médio (4 vCPU, 8GB RAM) com um modelo de fatura HTML de 200 elementos, media de 50 iterações após aquecimento:

Cenário IronPDF Puppeteer Sharp iText pdfHTML wkhtmltopdf
Página HTML simples ~150ms ~500ms ~200ms ~200ms
Layout CSS complexo (Flexbox/Grid) ~250ms ~600ms Falhas/Parcial ~400ms (quebrado)
Página pesada de JavaScript ~350ms ~800ms Falha Falhas/Parcial
Memória por operação ~80MB ~150MB ~60MB ~50MB
Inicialização fria (primeira geração) 2–5s 3–8s <1s <1s

O iText e owkhtmltopdfmostram inícios a frio mais rápidos porque não inicializam um motor de navegador — mas também não conseguem renderizar o mesmo conteúdo. A comparação de desempenho só é significativa para cenários onde todas as bibliotecas produzem saída correta.

Comparação de Código: Mesma Fatura, Três Bibliotecas

As diferenças entre essas bibliotecas são mais claras ao construir o mesmo documento. Aqui está uma fatura gerada de três maneiras.

IronPDF— Abordagem HTML/CSS

using IronPdf;

public class InvoiceGenerator
{
    public byte[] GenerateInvoice(InvoiceData data)
    {
        var renderer = new ChromePdfRenderer();

        string html = $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: 'Segoe UI', sans-serif; margin: 40px; }}
                h1 {{ color: #2c3e50; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th {{ background: #3498db; color: white; padding: 12px; text-align: left; }}
                td {{ border-bottom: 1px solid #e0e0e0; padding: 10px; }}
                .total {{ font-weight: bold; font-size: 1.2em; text-align: right; margin-top: 20px; }}
            </style>
        </head>
        <body>
            <h1>Invoice #{data.InvoiceNumber}</h1>
            <table>
                <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
                {string.Join("", data.Items.Select(i =>
                    $"<tr><td>{i.Name}</td><td>{i.Quantity}</td><td>${i.Price:F2}</td></tr>"))}
            </table>
            <p class='total'>Total: ${data.Total:F2}</p>
        </body>
        </html>";

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

public class InvoiceGenerator
{
    public byte[] GenerateInvoice(InvoiceData data)
    {
        var renderer = new ChromePdfRenderer();

        string html = $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: 'Segoe UI', sans-serif; margin: 40px; }}
                h1 {{ color: #2c3e50; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th {{ background: #3498db; color: white; padding: 12px; text-align: left; }}
                td {{ border-bottom: 1px solid #e0e0e0; padding: 10px; }}
                .total {{ font-weight: bold; font-size: 1.2em; text-align: right; margin-top: 20px; }}
            </style>
        </head>
        <body>
            <h1>Invoice #{data.InvoiceNumber}</h1>
            <table>
                <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
                {string.Join("", data.Items.Select(i =>
                    $"<tr><td>{i.Name}</td><td>{i.Quantity}</td><td>${i.Price:F2}</td></tr>"))}
            </table>
            <p class='total'>Total: ${data.Total:F2}</p>
        </body>
        </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        return pdf.BinaryData;
    }
}
$vbLabelText   $csharpLabel

QuestPDF— Abordagem Fluent API

using QuestPDF.Fluent;
using QuestPDF.Infrastructure;

public class InvoiceGenerator
{
    public byte[] GenerateInvoice(InvoiceData data)
    {
        var document = Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Size(PageSizes.A4);
                page.Margin(40);
                page.DefaultTextStyle(x => x.FontFamily("Segoe UI"));

                page.Header()
                    .Text($"Invoice #{data.InvoiceNumber}")
                    .FontSize(24).FontColor(Colors.Blue.Darken2);

                page.Content().Column(column =>
                {
                    column.Item().Table(table =>
                    {
                        table.ColumnsDefinition(cols =>
                        {
                            cols.RelativeColumn(3);
                            cols.RelativeColumn(1);
                            cols.RelativeColumn(1);
                        });

                        table.Header(header =>
                        {
                            header.Cell().Background(Colors.Blue.Medium).Padding(8)
                                .Text("Item").FontColor(Colors.White);
                            header.Cell().Background(Colors.Blue.Medium).Padding(8)
                                .Text("Qty").FontColor(Colors.White);
                            header.Cell().Background(Colors.Blue.Medium).Padding(8)
                                .Text("Price").FontColor(Colors.White);
                        });

                        foreach (var item in data.Items)
                        {
                            table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
                                .Padding(8).Text(item.Name);
                            table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
                                .Padding(8).Text(item.Quantity.ToString());
                            table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
                                .Padding(8).Text($"${item.Price:F2}");
                        }
                    });

                    column.Item().AlignRight().PaddingTop(20)
                        .Text($"Total: ${data.Total:F2}").FontSize(16).Bold();
                });
            });
        });

        using var stream = new MemoryStream();
        document.GeneratePdf(stream);
        return stream.ToArray();
    }
}
using QuestPDF.Fluent;
using QuestPDF.Infrastructure;

public class InvoiceGenerator
{
    public byte[] GenerateInvoice(InvoiceData data)
    {
        var document = Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Size(PageSizes.A4);
                page.Margin(40);
                page.DefaultTextStyle(x => x.FontFamily("Segoe UI"));

                page.Header()
                    .Text($"Invoice #{data.InvoiceNumber}")
                    .FontSize(24).FontColor(Colors.Blue.Darken2);

                page.Content().Column(column =>
                {
                    column.Item().Table(table =>
                    {
                        table.ColumnsDefinition(cols =>
                        {
                            cols.RelativeColumn(3);
                            cols.RelativeColumn(1);
                            cols.RelativeColumn(1);
                        });

                        table.Header(header =>
                        {
                            header.Cell().Background(Colors.Blue.Medium).Padding(8)
                                .Text("Item").FontColor(Colors.White);
                            header.Cell().Background(Colors.Blue.Medium).Padding(8)
                                .Text("Qty").FontColor(Colors.White);
                            header.Cell().Background(Colors.Blue.Medium).Padding(8)
                                .Text("Price").FontColor(Colors.White);
                        });

                        foreach (var item in data.Items)
                        {
                            table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
                                .Padding(8).Text(item.Name);
                            table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
                                .Padding(8).Text(item.Quantity.ToString());
                            table.Cell().BorderBottom(1).BorderColor(Colors.Grey.Lighten2)
                                .Padding(8).Text($"${item.Price:F2}");
                        }
                    });

                    column.Item().AlignRight().PaddingTop(20)
                        .Text($"Total: ${data.Total:F2}").FontSize(16).Bold();
                });
            });
        });

        using var stream = new MemoryStream();
        document.GeneratePdf(stream);
        return stream.ToArray();
    }
}
$vbLabelText   $csharpLabel

PdfSharp— Abordagem de Desenho por Coordenadas

using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;

public class InvoiceGenerator
{
    public byte[] GenerateInvoice(InvoiceData data)
    {
        var document = new PdfDocument();
        var page = document.AddPage();
        var gfx = XGraphics.FromPdfPage(page);

        var titleFont = new XFont("Arial", 24);
        var headerFont = new XFont("Arial", 12, XFontStyleEx.Bold);
        var bodyFont = new XFont("Arial", 12);

        double y = 40;

        gfx.DrawString($"Invoice #{data.InvoiceNumber}", titleFont,
            XBrushes.DarkBlue, 40, y);
        y += 50;

        // Table header — manually positioned
        double[] colX = { 40, 300, 400 };
        double rowHeight = 30;

        gfx.DrawRectangle(XBrushes.SteelBlue, 40, y, 500, rowHeight);
        gfx.DrawString("Item", headerFont, XBrushes.White, colX[0] + 10, y + 20);
        gfx.DrawString("Qty", headerFont, XBrushes.White, colX[1] + 10, y + 20);
        gfx.DrawString("Price", headerFont, XBrushes.White, colX[2] + 10, y + 20);
        y += rowHeight;

        // Each row drawn individually with explicit coordinates
        foreach (var item in data.Items)
        {
            gfx.DrawRectangle(XPens.LightGray, 40, y, 500, rowHeight);
            gfx.DrawString(item.Name, bodyFont, XBrushes.Black, colX[0] + 10, y + 20);
            gfx.DrawString(item.Quantity.ToString(), bodyFont, XBrushes.Black, colX[1] + 10, y + 20);
            gfx.DrawString($"${item.Price:F2}", bodyFont, XBrushes.Black, colX[2] + 10, y + 20);
            y += rowHeight;
        }

        y += 20;
        gfx.DrawString($"Total: ${data.Total:F2}", headerFont, XBrushes.Black, 440, y);

        using var stream = new MemoryStream();
        document.Save(stream);
        return stream.ToArray();
    }
}
using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;

public class InvoiceGenerator
{
    public byte[] GenerateInvoice(InvoiceData data)
    {
        var document = new PdfDocument();
        var page = document.AddPage();
        var gfx = XGraphics.FromPdfPage(page);

        var titleFont = new XFont("Arial", 24);
        var headerFont = new XFont("Arial", 12, XFontStyleEx.Bold);
        var bodyFont = new XFont("Arial", 12);

        double y = 40;

        gfx.DrawString($"Invoice #{data.InvoiceNumber}", titleFont,
            XBrushes.DarkBlue, 40, y);
        y += 50;

        // Table header — manually positioned
        double[] colX = { 40, 300, 400 };
        double rowHeight = 30;

        gfx.DrawRectangle(XBrushes.SteelBlue, 40, y, 500, rowHeight);
        gfx.DrawString("Item", headerFont, XBrushes.White, colX[0] + 10, y + 20);
        gfx.DrawString("Qty", headerFont, XBrushes.White, colX[1] + 10, y + 20);
        gfx.DrawString("Price", headerFont, XBrushes.White, colX[2] + 10, y + 20);
        y += rowHeight;

        // Each row drawn individually with explicit coordinates
        foreach (var item in data.Items)
        {
            gfx.DrawRectangle(XPens.LightGray, 40, y, 500, rowHeight);
            gfx.DrawString(item.Name, bodyFont, XBrushes.Black, colX[0] + 10, y + 20);
            gfx.DrawString(item.Quantity.ToString(), bodyFont, XBrushes.Black, colX[1] + 10, y + 20);
            gfx.DrawString($"${item.Price:F2}", bodyFont, XBrushes.Black, colX[2] + 10, y + 20);
            y += rowHeight;
        }

        y += 20;
        gfx.DrawString($"Total: ${data.Total:F2}", headerFont, XBrushes.Black, 440, y);

        using var stream = new MemoryStream();
        document.Save(stream);
        return stream.ToArray();
    }
}
$vbLabelText   $csharpLabel

A versão doIronPDFusa HTML/CSS — habilidades que a maioria dos desenvolvedores já possui. A versão doQuestPDFrequer aprender uma API fluente específica de domínio, mas proporciona estrutura. A versão PdfSharp requer calcular manualmente cada posição de pixel — cada deslocamento de coluna, cada altura de linha, cada borda desenhada individualmente.

Qual biblioteca devo escolher?

Quando avalio essas bibliotecas, a árvore de decisão é direta:

Precisa de HTML para PDF com CSS moderno? As opções práticas sãoIronPDFouPuppeteerSharp. OIronPDFlida com o Chromium internamente; OPuppeteer Sharpexige que você gerencie processos de navegador externos.wkhtmltopdfnão é uma opção para novos projetos. O pdfHTML do iText não consegue renderizar Flexbox ou Grid.

Construindo documentos programaticamente a partir de dados, sem HTML? A API fluente doQuestPDFé produtiva e bem projetada. PdfSharp fornece controle de nível inferior, mas requer significativamente mais código para layouts equivalentes.

Implantação multiplataforma (Linux, Docker, nuvem)? O IronPDF,QuestPDFePuppeteer Sharpfuncionam no Linux sem dependências de libgdiplus. O Aspose.PDF tem vazamentos de memória documentados no Linux. PdfSharp tem suporte parcial à plataforma com problemas conhecidos.

Restrições de licenciamento? PdfSharp (MIT) ePuppeteer Sharp(MIT) são gratuitos sem condições. OQuestPDFé gratuito para receitas abaixo de $1M. O iText exige conformidade com AGPL ou licenciamento comercial ($15K–$210K/ano). A licença perpétua doIronPDFcomeça em $749. OAsposecomeça em ~$999.

Antes de Comprometer-se

Teste com seu conteúdo real, não 'Hello World'. Faça a implantação na sua plataforma alvo cedo. Meça a memória em mais de 100 documentos, não apenas um. Leia o texto completo da licença com sua equipe jurídica. Verifique a latência de inicialização a frio se você estiver visando um ambiente sem servidor.

IronPDF oferece uma avaliação com funcionalidade completa para avaliação contra os seus requisitos específicos.