PORóWNANIE

HTMLDOC vs IronPDF: Przewodnik po porównaniu technicznym

Zaktualizowano:

W niniejszym porównaniu przeanalizowano oba narzędzia pod kątem istotnych aspektów technicznych, aby pomóc programistom i architektom w podjęciu świadomej decyzji dotyczącej ich potrzeb w zakresie obsługi plików PDF w środowisku .NET.

Zrozumienie HTMLDOC

HTMLDOC to starszy konwerter HTML na PDF, którego początki sięgają ery dot-com. Został on pierwotnie opracowany, zanim CSS stał się kluczowym elementem projektowania stron internetowych, przy użyciu niestandardowego parsera HTML z lat 90., który obsługuje HTML 3.2 z ograniczonymi funkcjami CSS. Narzędzie działa wyłącznie poprzez interfejsy wiersza poleceń, wymagając uruchamiania procesów z poziomu aplikacji .NET.

HTMLDOC wymaga zainstalowania zewnętrznego pliku wykonywalnego w systemie docelowym. Wszystkie interakcje używają ProcessStartInfo do wywołania narzędzia wiersza poleceń z flagami, takimi jak --webpage, --size, --header i --footer. W przypadku wprowadzania ciągów znaków HTML,HTMLDOCwymaga najpierw zapisania treści do plików tymczasowych, a następnie przekazania ścieżki do pliku jako argumentu.

Narzędzie jest dostępne na licencji GPL, która ma charakter wirusowy — każde oprogramowanie zawierające kod GPL musi być również udostępnione na tej samej licencji open source. Stanowi to wyzwanie dla komercyjnego tworzenia oprogramowania.

Zrozumienie IronPDF

IronPDF to natywna biblioteka .NET przeznaczona dla programistów, którzy potrzebują konwersji HTML do PDF w ekosystemie .NET. Biblioteka wykorzystuje nowoczesny silnik renderujący Chromium, zapewniający dokładne renderowanie HTML5, CSS3, JavaScript oraz nowoczesnych systemów układów, takich jak Flexbox i Grid.

IronPDF instalowany jest za pomocą pakietu NuGet (Install-Package IronPdf) i zapewnia bezpośredni dostęp do API poprzez klasę ChromePdfRenderer. Metody takie jak RenderHtmlAsPdf(), RenderHtmlFileAsPdf() i RenderUrlAsPdf() obsługują różne typy wejściowe. Konfiguracja korzysta z właściwości RenderingOptions dla rozmiaru papieru, marginesów, nagłówków i stopki. Biblioteka pracuje bezpośrednio z ciągami HTML w pamięci — nie są wymagańe żadne pliki tymczasowe.

IronPDF oferuje licencję komercyjną, która umożliwia integrację z oprogramowaniem własnościowym bez komplikacji związanych z licencjonowaniem GPL.

Porównanie architektury i integracji

Główna różnica między tymi narzędziami polega na ich architekturze integracji i możliwościach renderowania.

Funkcja HTMLDOC IronPDF
Silnik renderujący Niestandardowy parser HTML (lata 90.) Nowoczesny Chromium
Obsługa HTML/CSS HTML 3.2, minimalny CSS HTML5, CSS3, Flexbox, Grid
JavaScript None Pełna realizacja
Integracja z platformą .NET Brak (wiersz poleceń) Biblioteka natywna
Obsługa asynchroniczna Nie Pełna obsługa async/await
Licencja GPL (wirusowa) Komercjalne (liberalne)
Konserwacja Minimalne aktualizacje Aktywny rozwój
Wsparcie Tylko dla społeczności Professional wsparcie
Wdrożenie Zainstaluj plik binarny Pakiet NuGet

Architektura wiersza poleceńHTMLDOCwymaga uruchamiania procesów, zarządzania plikami tymczasowymi, escapingu powłoki oraz obsługi kodów wyjścia. Powoduje to zwiększenie złożoności i potencjalnych punktów awarii w środowiskach serwerowych. Natywna integracjaIronPDFz platformą .NET eliminuje te obawy dzięki bezpośrednim wywołaniom metod i standardowej obsłudze wyjątków.

Porównanie kodu: typowe operacje na plikach PDF

Konwersja pliku HTML do formatu PDF

Najbardziej podstawowa operacja pokazuje różnice architektoniczne.

HTMLDOC:

//HTMLDOCcommand-line approach
using System.Diagnostics;

class HtmlDocExample
{
    static void Main()
    {
        //HTMLDOCrequires external executable
        ProcessStartInfo startInfo = new ProcessStartInfo
        {
            FileName = "htmldoc",
            Arguments = "--webpage -f output.pdf input.html",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            CreateNoWindow = true
        };

        Process process = Process.Start(startInfo);
        process.WaitForExit();
    }
}
//HTMLDOCcommand-line approach
using System.Diagnostics;

class HtmlDocExample
{
    static void Main()
    {
        //HTMLDOCrequires external executable
        ProcessStartInfo startInfo = new ProcessStartInfo
        {
            FileName = "htmldoc",
            Arguments = "--webpage -f output.pdf input.html",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            CreateNoWindow = true
        };

        Process process = Process.Start(startInfo);
        process.WaitForExit();
    }
}
Imports System.Diagnostics

Class HtmlDocExample
    Shared Sub Main()
        'HTMLDOCrequires external executable
        Dim startInfo As New ProcessStartInfo With {
            .FileName = "htmldoc",
            .Arguments = "--webpage -f output.pdf input.html",
            .UseShellExecute = False,
            .RedirectStandardOutput = True,
            .CreateNoWindow = True
        }

        Dim process As Process = Process.Start(startInfo)
        process.WaitForExit()
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

Class IronPdfExample
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

HTMLDOC wymaga utworzenia obiektu ProcessStartInfo, skonfigurowania ścieżki wykonywalnej, zbudowania argumentów wiersza poleceń z odpowiednim eskapowaniem, uruchomienia procesu i oczekiwania na zakończenie. Obsługa błędów wymaga sprawdzania kodów wyjścia i analizowania standardowego wyjścia błędów.

IronPDF tworzy ChromePdfRenderer, wywołuje RenderHtmlFileAsPdf() ze ścieżką pliku i zapisuje za pomocą SaveAs(). Operacja składa się z trzech wierszy kodu ze standardową obsługą wyjątków .NET Standard.

Aby uzyskać informacje na temat zaawansowanych opcji renderowania HTML, zapoznaj się z przewodnikiem dotyczącym konwersji HTML do PDF.

Konwersja ciągu znaków HTML do formatu PDF

Konwersja ciągów znaków HTML pokazuje wymaganiaHTMLDOCdotyczące plików tymczasowych w porównaniu z przetwarzaniem w pamięci IronPDF.

HTMLDOC:

//HTMLDOCcommand-line with string input
using System.Diagnostics;
using System.IO;

class HtmlDocExample
{
    static void Main()
    {
        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        // Write HTML to temporary file
        string tempFile = Path.GetTempFileName() + ".html";
        File.WriteAllText(tempFile, htmlContent);

        ProcessStartInfo startInfo = new ProcessStartInfo
        {
            FileName = "htmldoc",
            Arguments = $"--webpage -f output.pdf {tempFile}",
            UseShellExecute = false,
            CreateNoWindow = true
        };

        Process process = Process.Start(startInfo);
        process.WaitForExit();

        File.Delete(tempFile);
    }
}
//HTMLDOCcommand-line with string input
using System.Diagnostics;
using System.IO;

class HtmlDocExample
{
    static void Main()
    {
        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        // Write HTML to temporary file
        string tempFile = Path.GetTempFileName() + ".html";
        File.WriteAllText(tempFile, htmlContent);

        ProcessStartInfo startInfo = new ProcessStartInfo
        {
            FileName = "htmldoc",
            Arguments = $"--webpage -f output.pdf {tempFile}",
            UseShellExecute = false,
            CreateNoWindow = true
        };

        Process process = Process.Start(startInfo);
        process.WaitForExit();

        File.Delete(tempFile);
    }
}
Imports System.Diagnostics
Imports System.IO

Class HtmlDocExample
    Shared Sub Main()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

        ' Write HTML to temporary file
        Dim tempFile As String = Path.GetTempFileName() & ".html"
        File.WriteAllText(tempFile, htmlContent)

        Dim startInfo As New ProcessStartInfo With {
            .FileName = "htmldoc",
            .Arguments = $"--webpage -f output.pdf {tempFile}",
            .UseShellExecute = False,
            .CreateNoWindow = True
        }

        Dim process As Process = Process.Start(startInfo)
        process.WaitForExit()

        File.Delete(tempFile)
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        string htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

Class IronPdfExample
    Shared Sub Main()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

HTMLDOC nie może akceptować ciągów HTML bezpośrednio—wymaga zapisania treści do tymczasowego pliku, używając Path.GetTempFileName() i File.WriteAllText(), następnie przekazania ścieżki pliku jako argumentu i ostatecznie usunięcia za pomocą File.Delete(). Powoduje to obciążenie wejścia/wyjścia i wymaga starannego czyszczenia, zwłaszcza w sytuacjach błędów.

Metoda RenderHtmlAsPdf() wIronPDFakceptuje ciągi HTML bezpośrednio, przetwarzając treść w pamięci, bez plików tymczasowych. Upraszcza to kod, zmniejsza liczbę operacji wejścia/wyjścia i eliminuje konieczność czyszczenia.

URL do pliku PDF z nagłówkami i stopkami

Konwersja adresów URL z nagłówkami i stopkami pokazuje różnice w podejściu do konfiguracji.

HTMLDOC:

//HTMLDOCcommand-line with URL and headers
using System.Diagnostics;

class HtmlDocExample
{
    static void Main()
    {
        //HTMLDOChas limited support for URLs and headers
        ProcessStartInfo startInfo = new ProcessStartInfo
        {
            FileName = "htmldoc",
            Arguments = "--webpage --header \"Page #\" --footer \"t\" -f output.pdf https://example.com",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            CreateNoWindow = true
        };

        Process process = Process.Start(startInfo);
        process.WaitForExit();

        // Note:HTMLDOCmay not render modern web pages correctly
    }
}
//HTMLDOCcommand-line with URL and headers
using System.Diagnostics;

class HtmlDocExample
{
    static void Main()
    {
        //HTMLDOChas limited support for URLs and headers
        ProcessStartInfo startInfo = new ProcessStartInfo
        {
            FileName = "htmldoc",
            Arguments = "--webpage --header \"Page #\" --footer \"t\" -f output.pdf https://example.com",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            CreateNoWindow = true
        };

        Process process = Process.Start(startInfo);
        process.WaitForExit();

        // Note:HTMLDOCmay not render modern web pages correctly
    }
}
CONVERTER NOT RUNNING
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

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

        renderer.RenderingOptions.TextHeader.CenterText = "Page {page}";
        renderer.RenderingOptions.TextFooter.CenterText = "{date}";

        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

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

        renderer.RenderingOptions.TextHeader.CenterText = "Page {page}";
        renderer.RenderingOptions.TextFooter.CenterText = "{date}";

        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

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

        renderer.RenderingOptions.TextHeader.CenterText = "Page {page}"
        renderer.RenderingOptions.TextFooter.CenterText = "{date}"

        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

HTMLDOC konfiguruje nagłówki i stopki za pomocą flag wiersza poleceń (--header, --footer) z ograniczonymi opcjami formatowania. W kodzie zaznaczono, żeHTMLDOCmoże nie wyświetlać poprawnie nowoczesnych stron internetowych ze względu na przestarzały parser HTML.

IronPDF używa RenderingOptions.TextHeader i RenderingOptions.TextFooter z właściwościami, takimi jak CenterText. Miejsca zastępcze używają {page} dla numerów stron i {date} dla dat. Metoda RenderUrlAsPdf() obsługuje renderowanie URL z pełną obsługą JavaScript za pomocą silnika Chromium.

Dowiedz się więcej o konfiguracji nagłówków i stopek w samouczkach IronPDF.

Przewodnik po mapowaniu API

Dla programistów rozważających migrację zHTMLDOClub porównujących możliwości, poniższe zestawienie przedstawia równoważne operacje:

Mapowanie flag wiersza poleceń do IronPDF

HTMLDOC Flag OdpowiednikIronPDF
--webpage -f output.pdf input.html renderer.RenderHtmlFileAsPdf("input.html").SaveAs("output.pdf")
--size A4 RenderingOptions.PaperSize = PdfPaperSize.A4
--size Letter RenderingOptions.PaperSize = PdfPaperSize.Letter
--landscape RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
--portrait RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
--top 20mm RenderingOptions.MarginTop = 20
--bottom 20mm RenderingOptions.MarginBottom = 20
--left 20mm RenderingOptions.MarginLeft = 20
--right 20mm RenderingOptions.MarginRight = 20
--header "..." RenderingOptions.TextHeader lub HtmlHeader
--footer "..." RenderingOptions.TextFooter lub HtmlFooter
--encryption pdf.SecuritySettings.MakeDocumentReadOnly(password)
--user-password xxx pdf.SecuritySettings.UserPassword
--owner-password xxx pdf.SecuritySettings.OwnerPassword
--embedfonts Domyślne zachowanie

Mapowanie składni symboli zastępczych

Znaczniki nagłówków i stopek mają różną składnię w poszczególnych narzędziach:

HTMLDOC IronPDF
$PAGE {page}
$PAGES {total-pages}
$DATE {date}
$TIME {time}
$TITLE {html-title}

Podsumowanie porównania funkcji

Funkcja HTMLDOC IronPDF
Obsługa HTML5 ❌ (HTML 3.2) ✅
Obsługa CSS3 ❌ (Minimal CSS) ✅
Flexbox/Grid ❌ ✅
Wykonanie kodu JavaScript ❌ ✅
Natywna biblioteka .NET ❌(Wiersz poleceń) ✅
Pakiet NuGet ❌ ✅
Przetwarzanie w pamięci ❌(Wymaga plików tymczasowych) ✅
Async/Await ❌ ✅
Bezpieczeństwo wątków ❌ ✅
Licencja komercyjna ❌ (GPL viral) ✅
Aktywny rozwój ⚠️ Minimalne ✅
Professional wsparcie ❌(Tylko społeczność) ✅

Kiedy zespoły rozważają przejście zHTMLDOCna IronPDF

Zespoły programistów rozważają przejście zHTMLDOCnaIronPDFz kilku powodów:

Przestarzałe standardy internetowe:HTMLDOCpowstał, zanim CSS stał się integralną częścią projektowania stron internetowych. Brakuje w nim obsługi CSS3, HTML5, Flexbox i Grid — wszystkich niezbędnych elementów nowoczesnych treści internetowych. Zespoły, które zauważają, że ich szablony HTML wyświetlają się nieprawidłowo lub wymagają uproszczenia w celu zapewnienia zgodności z HTMLDOC, często poszukują nowoczesnych alternatyw.

Brak obsługi JavaScript:HTMLDOCnie może wykonywać kodu JavaScript, co uniemożliwia wyświetlanie treści dynamicznych. Nowoczesne aplikacje internetowe często wykorzystują JavaScript do ładowania danych, tworzenia wykresów i elementów interaktywnych. Silnik Chromium firmyIronPDFzapewnia pełną obsługę języka JavaScript.

Kwestie związane z licencją GPL: Wirusowy charakter licencji GPL wymaga, aby każde oprogramowanie, które ją wykorzystuje, również było objęte licencją GPL — co stanowi problem w przypadku produktów komercyjnych. Zespoły tworzące oprogramowanie własnościowe często nie mogą korzystać z bibliotek na licencji GPL. Licencja komercyjnaIronPDFumożliwia integrację z oprogramowaniem własnościowym.

Złożoność wiersza poleceń:HTMLDOCwymaga uruchamiania procesów, tworzenia plików tymczasowych, analizowania wyników oraz escapowania znaków powłoki. Powoduje to zwiększenie złożoności kodu, potencjalne problemy z bezpieczeństwem oraz punkty awarii w środowiskach serwerowych. Natywny interfejs API .NET firmyIronPDFeliminuje te obawy.

Zależności platformowe:HTMLDOCwymaga zainstalowania pliku binarnego w systemie docelowym, co komplikuje wdrażanie i konteneryzację.IronPDFwdraża się za pośrednictwem NuGet bez żadnych zewnętrznych zależności.

Brak obsługi asynchronicznej: synchroniczne wykonywanie procesów wHTMLDOCblokuje wątki.IronPDFzapewnia pełną obsługę async/await w celu generowania plików PDF bez blokowania w nowoczesnych aplikacjach .NET.

Ograniczona konserwacja: Jako technologia z lat 90.,HTMLDOCotrzymuje minimalne aktualizacje.IronPDFzapewnia aktywny rozwój poprzez regularne wydania i poprawki bezpieczeństwa.

Mocne strony i kwestie do rozważenia

Atuty HTMLDOC

  • Trwała stabilność: dziesiątki lat stosowania w przypadku prostych dokumentów HTML
  • Open Source: Dostępne do publicznej modyfikacji na licencji GPL
  • Bezpłatne: brak kosztów licencji w przypadku użytkowania zgodnego z licencją GPL

Uwagi dotyczące HTMLDOC

  • Przestarzała technologia: niestandardowy parser HTML z lat 90. bez obsługi nowoczesnych stron internetowych
  • Tylko wiersz poleceń: brak natywnej integracji z platformą .NET
  • Licencja GPL: Licencja typu "viral" ogranicza wykorzystanie komercyjne
  • Wymagania dotyczące plików tymczasowych: Nie można bezpośrednio przetwarzać ciągów znaków HTML
  • Brak JavaScript: niemożliwe wyświetlanie treści dynamicznych
  • Zależności platformowe: Wymaga instalacji zewnętrznego pliku binarnego
  • Minimalna konserwacja: ograniczone aktualizacje i wsparcie wyłącznie ze strony społeczności

Atuty IronPDF

  • Nowoczesny silnik Chromium: pełna obsługa HTML5, CSS3 i JavaScript
  • Natywna biblioteka .NET: bezpośrednia integracja API bez uruchamiania procesów
  • Przetwarzanie w pamięci: nie są wymagańe pliki tymczasowe
  • Obsługa asynchroniczna: generowanie plików PDF bez blokowania
  • Bezpieczeństwo wątków: Bezpieczne dla wielowątkowych środowisk serwerowych
  • Licencja komercyjna: Wdrażanie w oprogramowaniu własnościowym
  • Aktywne wsparcie: Regularne aktualizacje i Professionalne wsparcie
  • Kompleksowe zasoby: obszerne samouczki i dokumentacja

Uwagi dotyczące IronPDF

  • Licencja komercyjna: Wymagana do użytku produkcyjnego

Wnioski

HTMLDOC iIronPDFreprezentują zasadniczo różne epoki technologii konwersji HTML do PDF. HTMLDOC, pochodzący z końca lat 90., umożliwia konwersję z wiersza poleceń przy użyciu niestandardowego parsera HTML, który powstał przed wprowadzeniem współczesnych standardów internetowych. Narzędzie wymaga instalacji zewnętrznego pliku binarnego, uruchamiania procesów, zarządzania plikami tymczasowymi i działa na licencji GPL.

IronPDF stanowi nowoczesną alternatywę dzięki natywnej integracji z platformą .NET, renderowaniu opartemu na silniku Chromium zapewniającym pełną obsługę HTML5/CSS3/JavaScript, przetwarzaniu w pamięci bez plików tymczasowych oraz wzorcom async/await umożliwiającym operacje nieblokujące. Biblioteka jest wdrażana za pośrednictwem NuGet bez żadnych zewnętrznych zależności.

W miarę jak organizacje planują wdrożenie .NET 10, C# 14 oraz tworzenie aplikacji do 2026 r., wybór pomiędzy starszymi narzędziami wiersza poleceń o wyglądzie z lat 90. a nowoczesnymi bibliotekami natywnymi zgodnymi z aktualnymi standardami internetowymi ma znaczący wpływ zarówno na tempo rozwoju, jak i jakość wyników. Zespoły wymagające nowoczesnego renderowania treści internetowych, natywnej integracji z platformą .NET lub licencji komercyjnych przekonają się, żeIronPDFskutecznie spełnia te wymagania.

Zacznij testować IronPDF, korzystając z bezpłatnej wersji próbnej, i zapoznaj się z obszerną dokumentacją, aby ocenić, czy rozwiązanie to spełnia Twoje konkretne wymagania.