Comparação de conversores de HTML para PDF: bibliotecas gratuitas e pagas para .NET

Início rápido: Criar PDF a partir de uma string HTML em C#

Converter strings HTML em PDF é fundamental para gerar documentos dinâmicos como faturas, relatórios e certificados. O IronPDF torna esse processo notavelmente simples.

Esta ferramenta converte strings HTML em PDF para conteúdo dinâmico, como faturas. O que leva horas em bibliotecas gratuitas, leva minutos com o mecanismo de renderização testado do IronPDF.

Saída

Início rápido: Converter página da Web em PDF com configurações personalizadas

O IronPDF oferece diversas opções de configuração para converter páginas da web em PDFs, incluindo renderização em JavaScript , margens personalizadas e configurações de tipo de mídia.

Esta ferramenta converte páginas da web em PDF com configurações personalizadas . O RenderDelay garante que o JavaScript seja carregado completamente, resolvendo problemas comuns de renderização . O suporte fornece exemplos de código e boas práticas.

Saída

Cálculo do ROI: Você economiza 40 horas por desenvolvedor por projeto em comparação com as alternativas gratuitas. A um custo de US$ 75 por hora, isso representa uma economia de US$ 3.000, valor superior ao custo da licença .

Veredito: O IronPDF é ideal para equipes que precisam de conversão confiável, documentos dinâmicos e controle total. O período de teste gratuito permite uma avaliação sem riscos.

using System.IO;
using DinkToPdf;
using DinkToPdf.Contracts;

var doc = new HtmlToPdfDocument()
{
    GlobalSettings = { PaperSize = PaperKind.A4 },
    Objects =
    {
        new ObjectSettings
        {
            HtmlContent = "<h1>Report</h1><div style='page-break-after: always;'>Page 1</div><div>Page 2</div>"
        }
    }
};

var converter = new BasicConverter(new PdfTools());
byte[] pdfBytes = converter.Convert(doc);
File.WriteAllBytes("Report.pdf", pdfBytes);

using System.IO;
using DinkToPdf;
using DinkToPdf.Contracts;

var doc = new HtmlToPdfDocument()
{
    GlobalSettings = { PaperSize = PaperKind.A4 },
    Objects =
    {
        new ObjectSettings
        {
            HtmlContent = "<h1>Report</h1><div style='page-break-after: always;'>Page 1</div><div>Page 2</div>"
        }
    }
};

var converter = new BasicConverter(new PdfTools());
byte[] pdfBytes = converter.Convert(doc);
File.WriteAllBytes("Report.pdf", pdfBytes);

Imports System.IO
Imports DinkToPdf
Imports DinkToPdf.Contracts

Dim doc As New HtmlToPdfDocument() With {
    .GlobalSettings = New GlobalSettings() With {
        .PaperSize = PaperKind.A4
    },
    .Objects = {
        New ObjectSettings() With {
            .HtmlContent = "<h1>Report</h1><div style='page-break-after: always;'>Page 1</div><div>Page 2</div>"
        }
    }
}

Dim converter As New BasicConverter(New PdfTools())
Dim pdfBytes As Byte() = converter.Convert(doc)
File.WriteAllBytes("Report.pdf", pdfBytes)

Isso cria documentos com várias páginas e quebras de página. Sua equipe gastará de 2 a 3 dias resolvendo problemas de dependências nativas — tempo que seria melhor aproveitado no desenvolvimento de novas funcionalidades.

Saída

using System.IO;
using DinkToPdf;
using DinkToPdf.Contracts;

var doc = new HtmlToPdfDocument()
{
    Objects = { new ObjectSettings { Page = "___PROTECTED_URL_82___" } }
};
var converter = new BasicConverter(new PdfTools());
byte[] pdfBytes = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdfBytes);

using System.IO;
using DinkToPdf;
using DinkToPdf.Contracts;

var doc = new HtmlToPdfDocument()
{
    Objects = { new ObjectSettings { Page = "___PROTECTED_URL_82___" } }
};
var converter = new BasicConverter(new PdfTools());
byte[] pdfBytes = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdfBytes);

Imports System.IO
Imports DinkToPdf
Imports DinkToPdf.Contracts

Dim doc = New HtmlToPdfDocument() With {
    .Objects = {New ObjectSettings With {.Page = "___PROTECTED_URL_82___" }}
}
Dim converter = New BasicConverter(New PdfTools())
Dim pdfBytes As Byte() = converter.Convert(doc)
File.WriteAllBytes("output.pdf", pdfBytes)

Este programa converte páginas da web em PDF. Os frameworks JavaScript modernos renderizam incorretamente. Não há suporte para fontes personalizadas ou design responsivo .

Saída

Análise de custos reais: Sua equipe gasta de 20 a 40 horas por ano em manutenção. A um custo de US$ 75 por hora, isso representa entre US$ 1.500 e US$ 3.000 — um valor superior à maioria das licenças comerciais .

Veredito: DinkToPdf é adequado para projetos pequenos, mas carece de recursos avançados . Considere o custo da manutenção a longo prazo antes de iniciar a produção.

Início rápido: Gere PDF a partir de HTML dinâmico com PuppeteerSharp

PuppeteerSharp oferece recursos eficazes de automação do navegador para geração de PDFs, especialmente úteis para conteúdo com uso intensivo de JavaScript.

Converte HTML dinâmico com execução em JavaScript . Sua equipe gasta de 8 a 12 horas para alcançar a estabilidade da produção, gerenciar falhas e complexidades assíncronas .

Saída

using PuppeteerSharp;
using PuppeteerSharp.Media;
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var chromePath = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

        if (!System.IO.File.Exists(chromePath))
        {
            Console.WriteLine("Chrome/Chromium executable not found.");
            return;
        }

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true,
            ExecutablePath = chromePath,
            Args = new[] { "--no-sandbox" }
        });

        await using var page = await browser.NewPageAsync();
        await page.GoToAsync("___PROTECTED_URL_83___");
        await page.PdfAsync("WebPage.pdf", new PdfOptions
        {
            MarginOptions = new MarginOptions { Top = "50px", Bottom = "50px" }
        });

        Console.WriteLine("PDF generated successfully!");
    }
}

using PuppeteerSharp;
using PuppeteerSharp.Media;
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var chromePath = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

        if (!System.IO.File.Exists(chromePath))
        {
            Console.WriteLine("Chrome/Chromium executable not found.");
            return;
        }

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true,
            ExecutablePath = chromePath,
            Args = new[] { "--no-sandbox" }
        });

        await using var page = await browser.NewPageAsync();
        await page.GoToAsync("___PROTECTED_URL_83___");
        await page.PdfAsync("WebPage.pdf", new PdfOptions
        {
            MarginOptions = new MarginOptions { Top = "50px", Bottom = "50px" }
        });

        Console.WriteLine("PDF generated successfully!");
    }
}

Imports PuppeteerSharp
Imports PuppeteerSharp.Media
Imports System
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim chromePath As String = "C:\Program Files\Google\Chrome\Application\chrome.exe"

        If Not System.IO.File.Exists(chromePath) Then
            Console.WriteLine("Chrome/Chromium executable not found.")
            Return
        End If

        Await Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
            .Headless = True,
            .ExecutablePath = chromePath,
            .Args = New String() {"--no-sandbox"}
        })

            Await Using page = Await browser.NewPageAsync()
                Await page.GoToAsync("___PROTECTED_URL_83___")
                Await page.PdfAsync("WebPage.pdf", New PdfOptions With {
                    .MarginOptions = New MarginOptions With {.Top = "50px", .Bottom = "50px"}
                })
            End Using
        End Using

        Console.WriteLine("PDF generated successfully!")
    End Function
End Module

A produção exige o gerenciamento de processos do Chrome, tratamento de falhas e lógica de repetição — o que aumenta a complexidade em comparação com bibliotecas dedicadas .

Saída

Detalhamento dos custos de infraestrutura:

• 2 a 4 GB de RAM adicionais por servidor
• DevOps Gerenciamento do Chrome: 10 a 20 horas anuais
• Depuração de falhas/vazamentos: 15 a 30 horas anualmente
• Custo oculto total: US$ 2.000 a US$ 4.000 por ano

Veredito: PuppeteerSharp se destaca na renderização com perfeição de pixels , mas requer investimento substancial em infraestrutura e conhecimento especializado em DevOps.

Início rápido: Criar PDF a partir de uma string HTML com SelectPdf

SelectPdf oferece uma abordagem direta para converter conteúdo HTML em documentos PDF, tornando-a adequada para aplicações empresariais que exigem resultados consistentes.

Converte HTML embutido para relatórios dinâmicos . SelectPdf lida corretamente com a maioria dos recursos do CSS , embora os recursos do CSS3 possam exigir soluções alternativas.

Saída

using SelectPdf;

var converter = new SelectPdf.HtmlToPdf();
converter.Options.DisplayHeader = true;
converter.Options.DisplayFooter = true;

var doc = converter.ConvertUrl("___PROTECTED_URL_84___");
doc.Save("WebPageWithHeader.pdf");

using SelectPdf;

var converter = new SelectPdf.HtmlToPdf();
converter.Options.DisplayHeader = true;
converter.Options.DisplayFooter = true;

var doc = converter.ConvertUrl("___PROTECTED_URL_84___");
doc.Save("WebPageWithHeader.pdf");

Imports SelectPdf

Dim converter As New SelectPdf.HtmlToPdf()
converter.Options.DisplayHeader = True
converter.Options.DisplayFooter = True

Dim doc = converter.ConvertUrl("___PROTECTED_URL_84___")
doc.Save("WebPageWithHeader.pdf")

Converte páginas web com cabeçalhos/rodapés personalizados para documentos com a identidade visual da marca. As opções de cabeçalho/rodapé atendem à maioria das necessidades comerciais.

Saída

Análise de custo-benefício:

• Licença: US$ 599 a US$ 2.399 por implantação
• Tempo economizado: 20 horas de desenvolvimento, 10 horas de manutenção
• Suporte: resposta em média de 24 a 48 horas
• Ponto de equilíbrio: 3 a 6 meses com mais de 100 PDFs por dia

Veredito: SelectPdf oferece recursos empresariais estáveis. Preços mais altos se justificam para equipes que priorizam a confiabilidade em detrimento de recursos modernos. ## Por que escolher EvoPdf para fluxos de trabalho em PDF orientados por API?

O EvoPdf oferece recursos avançados de conversão de HTML para PDF, ideais para processamento no servidor e cenários de alto volume de dados.

EvoPdf é ideal para aplicações empresariais com geração assíncrona para APIs web. O padrão de saída byte[] integra-se perfeitamente com arquiteturas de microsserviços .

Início rápido: Gere PDF com EvoPdf

A abordagem de matriz de bytes do EvoPdf oferece flexibilidade para fluxos de trabalho orientados por API e arquiteturas em nuvem.

Retorna [byte[]](https:// IronPDF.com/how-to/export-save-pdf-csharp) para facilitar a gravação de arquivos ou o streaming de API . Essa abordagem reduz o uso de memória em cenários de alto volume.

Saída

using EvoPdf;
using System.IO;

var htmlToPdf = new HtmlToPdfConverter();
byte[] pdfBytes = htmlToPdf.ConvertUrl("___PROTECTED_URL_85___");
File.WriteAllBytes("WebPageEvoPdf.pdf", pdfBytes);

using EvoPdf;
using System.IO;

var htmlToPdf = new HtmlToPdfConverter();
byte[] pdfBytes = htmlToPdf.ConvertUrl("___PROTECTED_URL_85___");
File.WriteAllBytes("WebPageEvoPdf.pdf", pdfBytes);

Imports EvoPdf
Imports System.IO

Dim htmlToPdf As New HtmlToPdfConverter()
Dim pdfBytes As Byte() = htmlToPdf.ConvertUrl("___PROTECTED_URL_85___")
File.WriteAllBytes("WebPageEvoPdf.pdf", pdfBytes)

Arquivamento rápido de páginas web sem pré-processamento de HTML. Gerencia com eficiência documentos grandes e layouts complexos.

Saída

Análise de Investimento:

• Licença: US$ 650 a US$ 3.250 por implantação
• Desempenho: processamento em lote 3 a 5 vezes mais rápido
• Economia para desenvolvedores: integração de API em 30 a 40 horas
• Infraestrutura: Redução do número de servidores por meio de memória eficiente.
• Retorno sobre o investimento (ROI): 2 a 4 meses com mais de 1000 PDFs por dia.

Veredito: EvoPdf se destaca em fluxos de trabalho orientados por API e geração de alto volume . O retorno do investimento é rápido para arquiteturas com foco em APIs .