Iron Suite for .NET

10 bibliotek .NET. Jeden kompletny pakiet dokumentów.

Odkryj Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

PORÓWNANIE

Kaizen.io vs IronPDF: Przewodnik po porównaniu technicznym

Curtis Chau

Updated: 20 czerwca 2026

Kiedy deweloperzy .NET muszą konwertować zawartość HTML na dokumenty PDF, mogą wybrać między usługami opartymi na kontenerach jakKaizen.io HTML-to-PDFlub natywnymi bibliotekami .NET jak IronPDF. W niniejszym porównaniu przeanalizowano oba podejścia pod kątem kluczowych aspektów technicznych, aby pomóc programistom, architektom i osobom odpowiedzialnym za podejmowanie decyzji technicznych w wyborze odpowiedniego rozwiązania dla ich procesów generowania plików PDF.

Czym jest Kaizen.io HTML-to-PDF?

Kaizen.io HTML-to-PDF to samodzielnie hostowany kontener Docker, który przekształca zawartość HTML w dokumenty PDF za pomocą REST API. Programiści wdrażają kontener (np. docker run kaizenio.azurecr.io/html-to-pdf:latest) i wysyłają żądania HTTP POST z ładunkami JSON do http://localhost:8080/html-to-pdf. Usługa zwraca renderowany PDF w treści odpowiedzi.

Ta architektura oznacza, że deweloperzy zarządzają infrastrukturą kontenerów sami, ale nie muszą osadzać silnika renderującego w swojej aplikacji. Integracja wykorzystuje standardowych klientów HTTP w dowolnym języku — nie ma pakietu Kaizen.io NuGet ani SDK .NET.

Jednakże ta architektura wprowadza zależność od Dockera, wymaga orkiestracji kontenerów dla wdrożeń produkcyjnych i dodaje dodatkowe przetwarzanie HTTP round-trip dla każdej konwersji.

Czym jest IronPDF?

IronPDF to natywna biblioteka C#, która przetwarza generowanie plików PDF całkowicie w ramach aplikacji .NET. Zamiast wysyłać dane na serwery zewnętrzne,IronPDF wykorzystuje wbudowany silnik renderujący Chromium do lokalnej konwersji HTML, CSS i JavaScript na dokumenty PDF.

Klasa ChromePdfRenderer służy jako główny interfejs do konwersji. Programiści konfigurują zachowanie renderowania poprzez właściwość RenderingOptions, następnie wywołują metody takie jak RenderHtmlAsPdf() lub RenderUrlAsPdf(), aby generować dokumenty PDF. Powstały obiekt PdfDocument zapewnia bezpośredni dostęp do danych binarnych, zapisywania plików i dodatkowych możliwości manipulacyjnych.

Ten model przetwarzania lokalnego eliminuje zależności sieciowe, dając jednocześnie programistom pełną kontrolę nad konfiguracją renderowania i prywatnością danych.

Porównanie Architektury: Usługa Kontenerowa vs Wbudowana Biblioteka

Podstawowa różnica międzyKaizen.io HTML-to-PDFa IronPDF polega na sposobie integracji renderowania PDF z aplikacją. To rozróżnienie architektoniczne wpływa na złożoność wdrażania, cechy wydajnościowe i doświadczenie deweloperów.

Funkcja	Kaizen.io HTML-to-PDF	IronPDF
Model wdrożenia	Samodzielnie hostowany kontener Docker	Pakiet NuGet (wbudowany w aplikację)
Integracja	HTTP POST do punktu końcowego kontenera	Bezpośrednie wywołania metod C#
Przetwarzanie	Odseparowany proces kontenera przez HTTP	Renderowanie w procesie
Infrastruktura	Wymaga Docker + orkiestracji kontenerów	Brak zależności zewnętrznych
Dodatkowe Przetwarzanie	HTTP round-trip na konwersję	Bezpośrednie przetwarzanie w pamięci
Tryb offline	Wymaga działającego kontenera	Pełna funkcjonalność
SDK/Pakiet	Brak SDK .NET — używa standardowego HttpClient	Natywna biblioteka .NET
Model cenowy	Licencja jednorazowa	Licencja jednorazowa lub roczna

Oba podejścia przetwarzają dokumenty w obrębie własnej infrastruktury — Kaizen.io działa jako kontener Docker na Twoich serwerach, a IronPDF działa bezpośrednio w Twojej aplikacji .NET. Kluczowa różnica jest operacyjna: Kaizen.io wymaga zarządzania oddzielną usługą kontenerową i komunikacji przez HTTP, podczas gdy IronPDF osadza silnik renderujący bezpośrednio w aplikacji bez zewnętrznych procesów.

Podstawowa konwersja HTML do PDF

Najprostszy scenariusz generowania pliku PDF polega na konwersji ciągu znaków HTML na plik PDF. Porównanie wzorców kodu ujawnia różnice w projektowaniu API i złożoności.

Wdrożenie Kaizen.io HTML-to-PDF:

// Requires: docker run -d -p 8080:8080 kaizenio.azurecr.io/html-to-pdf:latest
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        var html = "<html><body><h1>Hello World</h1></body></html>";

        var response = await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            new { html });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

// Requires: docker run -d -p 8080:8080 kaizenio.azurecr.io/html-to-pdf:latest
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        var html = "<html><body><h1>Hello World</h1></body></html>";

        var response = await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            new { html });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim response = Await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            New With {Key .html = html})
        Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Function
End Module

Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim response = Await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            New With {Key .html = html})
        Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Function
End Module

Wdrożenie IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></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();
        var html = "<html><body><h1>Hello World</h1></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 html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Kaizen.io wymaga konfiguracji kontenera Docker i wykonywania żądań HTTP — brak SDK .NET lub pakietu NuGet. REST API zwraca surowe bajty PDF.IronPDF zwraca obiekt PdfDocument z wygodną metodą SaveAs() oraz dostępem do dodatkowych możliwości manipulacji PDF poprzez obiekt dokumentu.

Konwersja pliku HTML do formatu PDF

Podczas konwersji plików HTML, a nie ciągów znaków, biblioteki obsługują odczyt plików w inny sposób.

Podejście Kaizen.io do konwersji HTML na PDF:

// Requires: docker run -d -p 8080:8080 kaizenio.azurecr.io/html-to-pdf:latest
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        var htmlContent = File.ReadAllText("input.html");

        var response = await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            new { html = htmlContent });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("document.pdf", pdfBytes);
    }
}

// Requires: docker run -d -p 8080:8080 kaizenio.azurecr.io/html-to-pdf:latest
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        var htmlContent = File.ReadAllText("input.html");

        var response = await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            new { html = htmlContent });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("document.pdf", pdfBytes);
    }
}

Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        Dim htmlContent As String = File.ReadAllText("input.html")

        Dim response = Await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            New With {.html = htmlContent})
        Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("document.pdf", pdfBytes)
    End Function
End Module

Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        Dim htmlContent As String = File.ReadAllText("input.html")

        Dim response = Await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            New With {.html = htmlContent})
        Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("document.pdf", pdfBytes)
    End Function
End Module

Podejście IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("document.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("document.pdf");
    }
}

Imports IronPdf
Imports System
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("document.pdf")
    End Sub
End Class

Imports IronPdf
Imports System
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("document.pdf")
    End Sub
End Class

REST API Kaizen.io akceptuje zawartość HTML jako string JSON, więc deweloperzy muszą najpierw odczytać plik i wysłać go przez HTTP.IronPDF dostarcza dedykowaną metodę RenderHtmlFileAsPdf, która obsługuje odczyt pliku wewnętrznie, redukując kod powtarzalny.IronPDF wspiera również konfigurację stron bezpośrednio przez RenderingOptions, podczas gdy opcje konfiguracji Kaizen.io zależą od tego, co akceptuje punkt końcowy REST API.

URL do pliku PDF z nagłówkami i stopkami

Profesjonalne dokumenty zazwyczaj wymagają nagłówków i stopek z numerami stron, oznaczeniami firmy lub metadanymi dokumentu. Obie biblioteki obsługują tę funkcjonalność przy użyciu różnych wzorców konfiguracyjnych.

Podejście Kaizen.io do konwersji HTML na PDF:

REST API Kaizen.io akceptuje ciąg HTML za pomocą POST http://localhost:8080/html-to-pdf. Dla konwersji URL-to-PDF aplikacja musi najpierw pobrać zawartość strony internetowej, a następnie wysłać ją do kontenera. Wspieranie nagłówków/stopki zależy od możliwości API kontenera — zapoznaj się z dokumentacją Kaizen.io w sprawie dostępnych opcji.

// Requires: docker run -d -p 8080:8080 kaizenio.azurecr.io/html-to-pdf:latest
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        // Kaizen.io accepts HTML content — URL fetching must be done separately
        var html = await client.GetStringAsync("https://example.com");

        var response = await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            new { html });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}

// Requires: docker run -d -p 8080:8080 kaizenio.azurecr.io/html-to-pdf:latest
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        // Kaizen.io accepts HTML content — URL fetching must be done separately
        var html = await client.GetStringAsync("https://example.com");

        var response = await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            new { html });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}

Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        ' Kaizen.io accepts HTML content — URL fetching must be done separately
        Dim html As String = Await client.GetStringAsync("https://example.com")

        Dim response = Await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            New With {Key .html = html})
        Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Function
End Module

Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        ' Kaizen.io accepts HTML content — URL fetching must be done separately
        Dim html As String = Await client.GetStringAsync("https://example.com")

        Dim response = Await client.PostAsJsonAsync(
            "http://localhost:8080/html-to-pdf",
            New With {Key .html = html})
        Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Function
End Module

IronPDF z nagłówkami i stopkami:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.TextHeader.CenterText = "Company Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page} of {total-pages}";
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.TextHeader.CenterText = "Company Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page} of {total-pages}";
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf
Imports System
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.TextHeader.CenterText = "Company Header"
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page} of {total-pages}"
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

Imports IronPdf
Imports System
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.TextHeader.CenterText = "Company Header"
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page} of {total-pages}"
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

IronPDF oferuje zarówno TextFooter dla prostych nagłówków tekstowych, jak i HtmlFooter dla skomplikowanych projektów opartych na HTML. Klasa RenderingOptions centralizuje całą konfigurację, ułatwiając odkrywanie dostępnych opcji dzięki autouzupełnianiu w środowisku IDE.

IronPDF obsługuje dynamiczne zastępniki w nagłówkach i stopkach, w tym {page}, {total-pages}, {date}, {time}, {html-title} i {url}. Możliwości nagłówków/stopki Kaizen.io zależą od REST API kontenera — zapoznaj się z dokumentacją w sprawie obsługiwanych opcji.

Porównanie projektów API

Podejścia integracyjne są zasadniczo różne. Kaizen.io to REST API — deweloperzy wysyłają żądania HTTP z ładunkami JSON i otrzymują bajty PDF. Nie ma klas .NET, metod czy obiektów konfiguracji do mapowania.IronPDF to natywna biblioteka .NET z bogatym API C#.

Porównanie Wzorców Integracyjnych

Kaizen.io (REST API)	IronPDF(biblioteka C#)
`POST /html-to-pdf` z `{"html": "...`	`renderer.RenderHtmlAsPdf(html)`
Pobranie zawartości URL, potem POST HTML	`renderer.RenderUrlAsPdf(url)`
Odczyt pliku, potem POST HTML	`renderer.RenderHtmlFileAsPdf(path)`
Treść odpowiedzi HTTP (bajty PDF)	`pdf.SaveAs(path)` lub `pdf.BinaryData`
Parametry zapytania JSON	`renderer.RenderingOptions.*` właściwości

Kiedy zespoły rozważają przejście z Kaizen.io na IronPDF

Kilka czynników skłania zespoły do rozważenia IronPDF jako alternatywy dla Kaizen.io HTML-to-PDF:

Prostsze Wdrożenie: Kaizen.io wymaga infrastruktury Docker — orkiestracji kontenerów, monitorowania zdrowia, zarządzania portami i aktualizacji kontenerów.IronPDF instaluje się jako pakiet NuGet bez zewnętrznych procesów ani zależności od kontenerów.

Wydajność: Każda konwersja Kaizen.io obejmuje przetwarzanie HTTP round-trip do procesu kontenera.IronPDF renderuje w procesie, unikając serializacji i przesyłu sieciowego dla każdej konwersji.

Brak Zależności od Kontenera: Aplikacje, które muszą generować PDF-y bez Dockera — aplikacje desktopowe, proste serwery webowe czy środowiska, gdzie kontenery są niedostępne — korzystają z wbudowanej architektury IronPDF.

Bardziej Rozbudowane API: REST API Kaizen.io akceptuje HTML i zwraca bajty PDF — to jest jego zakres.IronPDF dostarcza pełne API .NET z łączeniem PDF, dzieleniem, znakami wodnymi, wypełnianiem formularzy, podpisami cyfrowymi i ustawieniami zabezpieczeń wykraczającymi poza podstawowe generowanie.

**Doświadczenie Dewelopera:**IronPDF integruje się bezpośrednio z kodem C# z podpowiadaniem w IDE, bezpieczną typami i metodami synchronicznymi lub asynchronicznymi. Kaizen.io wymaga kodu boilerplate klienta HTTP, serializacji JSON i ręcznej obsługi tablicy bajtów.

Różnice w typach zwracanych wartości

Kluczowa różnica w API wpływa na sposób, w jaki aplikacje obsługują wyniki konwersji:

Kaizen.io zwraca surowe bajty odpowiedzi HTTP:

var response = await client.PostAsJsonAsync("http://localhost:8080/html-to-pdf", new { html });
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
File.WriteAllBytes("output.pdf", pdfBytes);

var response = await client.PostAsJsonAsync("http://localhost:8080/html-to-pdf", new { html });
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
File.WriteAllBytes("output.pdf", pdfBytes);

Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Dim response = Await client.PostAsJsonAsync("http://localhost:8080/html-to-pdf", New With {Key .html})
Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
File.WriteAllBytes("output.pdf", pdfBytes)

Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Dim response = Await client.PostAsJsonAsync("http://localhost:8080/html-to-pdf", New With {Key .html})
Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
File.WriteAllBytes("output.pdf", pdfBytes)

IronPDF zwraca obiekty PdfDocument:

var pdf = renderer.RenderHtmlAsPdf(html);
byte[] bytes = pdf.BinaryData;  // Get bytes if needed
pdf.SaveAs("output.pdf");        // Or save directly

var pdf = renderer.RenderHtmlAsPdf(html);
byte[] bytes = pdf.BinaryData;  // Get bytes if needed
pdf.SaveAs("output.pdf");        // Or save directly

Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim bytes As Byte() = pdf.BinaryData  ' Get bytes if needed
pdf.SaveAs("output.pdf")  ' Or save directly

Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim bytes As Byte() = pdf.BinaryData  ' Get bytes if needed
pdf.SaveAs("output.pdf")  ' Or save directly

Obiekt PdfDocumentIronPDF zapewnia dostęp do danych binarnych przez właściwość BinaryData, a także oferuje wygodne metody takie jak SaveAs(). Poza podstawowym wyjściem, PdfDocument umożliwia dodatkowe operacje, takie jak łączenie dokumentów, dodawanie znaków wodnych, wypełnianie formularzy i stosowanie ustawień zabezpieczeń.

Instalacja i konfiguracja

Proces instalacji znacznie różni się w zależności od wybranego podejścia:

Konfiguracja Kaizen.io:

docker pull kaizenio.azurecr.io/html-to-pdf:latest
docker run -d -p 8080:8080 kaizenio.azurecr.io/html-to-pdf:latest

docker pull kaizenio.azurecr.io/html-to-pdf:latest
docker run -d -p 8080:8080 kaizenio.azurecr.io/html-to-pdf:latest

SHELL

Brak pakietu NuGet — integracja korzysta ze standardowego HttpClient do wywołania REST API kontenera.

Konfiguracja IronPDF:

> dotnet add package IronPdf

dotnet add package IronPdf

Wymaga jednorazowego wprowadzenia klucza licencyjnego podczas uruchamiania aplikacji:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

IronPDF obsługuje .NET Framework 4.6.2+ oraz .NET Core 3.1+ / .NET 5+, dzięki czemu jest kompatybilny z nowoczesnym programowaniem .NET ukierunkowanym na .NET 10 i C# 14. Pojedynczy pakiet NuGet zawiera wszystkie niezbędne zależności bez pakietów specyficznych dla platformy.

Uwagi dotyczące obsługi błędów

Podejścia oparte na kontenerach i wbudowane biblioteki wymagają różnego zarządzania błędami:

Scenariusze błędów Kaizen.io:

Kontener nie działa lub jest niedostępny
Awaria połączenia HTTP do punktu końcowego kontenera
Limity zasobów kontenera (pamięć, CPU)
Obsługa przekroczenia limitu czasu żądania
Uruchamianie kontenera/monitorowanie zdrowia

Scenariusze błędów IronPDF:

Problemy z parsowaniem HTML
Błędy ładowania zasobów
Ograniczenia pamięci w przypadku dużych dokumentów
Błędy dostępu do systemu plików

Zespoły migrujące z Kaizen.io do IronPDF mogą uprościć obsługę błędów, usuwając logikę klienta HTTP, kontrole zdrowia kontenera i problemy z komunikacją międzyprocesową. Renderowanie w procesie przez IronPDF eliminuje tryby awarii związane z zarządzaniem oddzielną usługą kontenerową.

Kwestie związane z wydajnością

IronPDF inicjuje swój silnik renderujący Chromium przy pierwszym użyciu, co może spowodować krótkie opóźnienie podczas początkowej konwersji. W przypadku aplikacji, których uruchomienie wymaga krótkiego czasu reakcji, rozgrzanie renderera podczas inicjalizacji aplikacji zapobiega wpływowi tego opóźnienia na operacje widoczne dla użytkownika:

// In Program.cs or Startup.cs
new ChromePdfRenderer().RenderHtmlAsPdf("<html></html>");

// In Program.cs or Startup.cs
new ChromePdfRenderer().RenderHtmlAsPdf("<html></html>");

' In Program.vb or Startup.vb
Call New ChromePdfRenderer().RenderHtmlAsPdf("<html></html>")

' In Program.vb or Startup.vb
Call New ChromePdfRenderer().RenderHtmlAsPdf("<html></html>")

Po inicjalizacji kolejne konwersje są wykonywane z pełną prędkością. DokumentacjaIronPDF zawiera dodatkowe techniki optymalizacji dla scenariuszy wymagających przetwarzania dużych ilości danych.

Podejmowanie decyzji

Wybór międzyKaizen.io HTML-to-PDFa IronPDF zależy od konkretnych wymagań:

Rozważ Kaizen.io HTML-to-PDF, jeżeli: Już używasz Dockera w swojej infrastrukturze, chcesz rozdzielić renderowanie PDF od procesu aplikacji, Twoje potrzeby dotyczące konwersji ograniczają się do podstawowego HTML-to-PDF i preferujesz integrację opartą na HTTP, niezależną od języka.

Rozważ IronPDF, jeżeli: Chcesz natywnej biblioteki .NET bez zależności od kontenerów, potrzebujesz manipulacji PDF wykraczających poza podstawowe generowanie (łączenie, znak wodny, podpis, szyfrowanie), preferujesz bezpośrednią integrację API C# z wsparciem IDE lub Twoje środowisko wdrożeniowe nie obsługuje Dockera.

Dla zespołów tworzących nowoczesne aplikacje .NET w 2025 r. i planujących działania na 2026 r. dostosowanie IronPDF do lokalnego przetwarzania, prywatności danych i natywnej integracji z .NET oferuje przekonujące korzyści. Możliwość pełnej kontroli nad konfiguracją renderowania, wyeliminowanie zależności zewnętrznych oraz przetwarzanie dokumentów bez przesyłania danych na zewnątrz odpowiada typowym wymaganiom Enterprise.

Pierwsze kroki z IronPDF

Aby ocenićIronPDF pod kątem swoich potrzeb w zakresie konwersji HTML do PDF:

Zainstaluj pakiet IronPDF NuGet: Install-Package IronPdf
Zapoznaj się z samouczkiem dotyczącym konwersji HTML do PDF, aby poznać wzorce konwersji
Poznaj konwersję adresów URL do formatu PDF w celu przechwytywania stron internetowych
Konfiguracja nagłówków i stopek w profesjonalnych dokumentach

Samouczki IronPDF zawierają wyczerpujące przykłady typowych scenariuszy, a Dokumentacja API opisuje wszystkie dostępne klasy i metody.

Kaizen.io HTML-to-PDF i IronPDF reprezentują różne podejścia architektoniczne do generowania PDF. Kaizen.io działa jako samodzielnie hostowany kontener Docker z REST API, podczas gdy IronPDF to natywna biblioteka .NET, która osadza silnik renderujący bezpośrednio w aplikacji.

Dla zespołów .NET, które chcą bezpośredniej integracji biblioteki bez infrastruktury kontenerowej,IronPDF oferuje prostszy model wdrażania z bogatszym zestawem funkcji — w tym manipulację PDF, zabezpieczenia i podpisy cyfrowe wykraczające poza podstawowe konwersje HTML-to-PDF.

Oceń obie opcje w kontekście swojej infrastruktury wdrożeniowej, wymagań funkcjonalnych i preferencji integracyjnych.

Zwróć uwagę: Kaizen.io jest zarejestrowanym znakiem towarowym swojego właściciela. Ta witryna nie jest powiązana, zatwierdzona ani sponsorowana przez Kaizenio, Inc.. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.