Porównanie konwerterów HTML do PDF: Darmowe vs Płatne biblioteki dla .NET

Szybki start: Tworzenie pliku PDF z ciągu znaków HTML w języku C#

Konwersja ciągów HTML do formatu PDF ma fundamentalne znaczenie dla generowania dokumentów dynamicznych, takich jak faktury, raporty i certyfikaty. IronPDF sprawia, że proces ten jest niezwykle prosty.

Służy to do konwersji ciągów HTML do formatu PDF w przypadku treści dynamicznych, takich jak faktury. To, co przy użyciu darmowych bibliotek zajmuje godziny, dzięki sprawdzonemu silnikowi renderowania IronPDF zajmuje zaledwie kilka minut.

Wynik

Szybki start: Konwersja strony internetowej do formatu PDF z ustawieniami niestandardowymi

IronPDF oferuje szerokie możliwości konfiguracji konwersji stron internetowych do formatu PDF, w tym renderowanie JavaScript, niestandardowe marginesy oraz ustawienia typu nośnika.

Narzędzie to konwertuje strony internetowe do formatu PDF z wykorzystaniem ustawień niestandardowych. RenderDelay zapewnia całkowite załadowanie kodu JavaScript, rozwiązując typowe problemy z renderowaniem. Wsparcie zawiera przykłady kodu i najlepsze praktyki.

Wynik

Obliczenie zwrotu z inwestycji: Oszczędzasz 40 godzin na programistę na projekt w porównaniu z darmowymi alternatywami. Przy stawce 75 USD za godzinę oznacza to oszczędność 3000 USD — przewyższającą koszty licencji.

Werdykt: IronPDF jest odpowiedni dla zespołów potrzebujących niezawodnej konwersji, dynamicznych dokumentów i pełnej kontroli. Bezpłatna wersja próbna umożliwia ocenę bez ryzyka.

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)

Powstają w ten sposób wielostronicowe dokumenty z podziałami. Twój zespół poświęci 2–3 dni na rozwiązywanie problemów związanych z zależnościami natywnymi — czas ten lepiej przeznaczyć na funkcje.

Wynik

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)

To narzędzie konwertuje strony internetowe do formatu PDF. Nowoczesne frameworki JavaScript wyświetlają się nieprawidłowo. Brak obsługi niestandardowych czcionek lub responsywnego projektowania.

Wynik

Analiza rzeczywistych kosztów: Twój zespół poświęca rocznie 20–40 godzin na konserwację. Przy stawce 75 USD za godzinę daje to 1500–3000 USD — kwotę przewyższającą większość licencji komercyjnych.

Verdict: DinkToPdf suits small projects but lacks advanced features. Przed wdrożeniem do produkcji należy wziąć pod uwagę długoterminowe obciążenie związane z utrzymaniem.

Quickstart: Generate PDF from Dynamic HTML with PuppeteerSharp

PuppeteerSharp provides effective browser automation capabilities for PDF generation, especially useful for JavaScript-heavy content.

Konwertuje dynamiczny kod HTML przy użyciu skryptów JavaScript. Twój zespół poświęca 8–12 godzin na zapewnienie stabilności produkcji, zarządzanie awariami i złożonością operacji asynchronicznych.

Wynik

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

Produkcja wymaga zarządzania procesami Chrome, obsługi awarii i logiki ponownych prób — co zwiększa złożoność w porównaniu z dedykowanymi bibliotekami.

Wynik

Podział kosztów infrastruktury:

• Dodatkowe 2–4 GB pamięci RAM na serwer
• DevOps Chrome management: 10-20 hours annually
• Debugowanie awarii/wycieków: 15–30 godzin rocznie
• Łączny koszt ukryty: 2 000–4 000 USD rocznie

Verdict: PuppeteerSharp excels at pixel-perfect rendering but requires substantial infrastructure investment and DevOps expertise.

Quickstart: Create PDF from HTML String with SelectPdf

SelectPdf offers a straightforward approach to converting HTML content to PDF documents, making it suitable for enterprise applications requiring consistent output.

Converts inline HTML for dynamic reports. SelectPdf handles most CSS correctly, though CSS3 features may need workarounds.

Wynik

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

Converts web pages with custom headers/footers for branded documents. Header/footer options meet most business needs.

Wynik

Cost-Benefit Analysis:

• License: $599-$2,399 by deployment
• Time Saved: 20 hours development, 10 hours maintenance
• Support: 24-48 hour average response
• Break-even: 3-6 months at 100+ PDFs daily

Verdict: SelectPdf delivers stable enterprise features. Higher pricing justified for teams prioritizing reliability over modern features.## Why Choose EvoPdf for API-Driven PDF Workflows?

EvoPdf offers advanced HTML to PDF conversion capabilities, ideal for server-side processing and high-throughput scenarios.

EvoPdf is well-suited for enterprise applications with asynchronous generation for web APIs. The byte[] output pattern integrates seamlessly with microservices architectures.

Quickstart: Generate PDF with EvoPdf

EvoPdf's byte array approach offers flexibility for API-driven workflows and cloud architectures.

Returns byte[] for easy file writing or API streaming. This approach reduces memory usage in high-volume scenarios.

Wynik

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)

Quick web page archiving without HTML preprocessing. Efficiently handles large documents and complex layouts.

Wynik

Investment Analysis:

• License: $650-$3,250 by deployment
• Performance: 3-5x faster batch processing
• Developer Savings: 30-40 hours API integration
• Infrastructure: Reduced servers via efficient memory
• ROI: 2-4 months at 1000+ PDFs/day

Verdict: EvoPdf excels for API-driven workflows and high-volume generation. Investment returns quickly for API-first architectures.