Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Przewodniki migracji
  4. migracja z kaizen.io do IronPDF
PRZEWODNIKI MIGRACJI

Jak przeprowadzić migrację z Kaizen.io do IronPDF w języku C#

Curtis Chau
Curtis Chau
Zaktualizowano:

Przejście z Kaizen.io HTML-to-PDF naIronPDFprzekształca proces obsługi plików PDF w środowisku .NET z usługi zależnej od chmury, wiążącej się z opóźnieniami sieciowymi i obawami dotyczącymi prywatności danych, w lokalną bibliotekę działającą w ramach procesu, która przechowuje dane w ramach infrastruktury użytkownika. Niniejszy przewodnik przedstawia kompleksową, krok po kroku ścieżkę migracji, która eliminuje zależności od zewnętrznych interfejsów API oraz model rozliczeń oparty na liczbie żądań dla profesjonalnych programistów .NET.

Dlaczego warto przejść z Kaizen.io na IronPDF

Wyzwania związane z API w chmurze

Kaizen.io HTML-to-PDF, podobnie jak inne usługi PDF w chmurze, wprowadza ograniczenia, które mają wpływ na aplikacje produkcyjne:

  1. Zależność od chmury: Wymaga stałego połączenia z Internetem i dostępności usług zewnętrznych. Jeśli usługa Kaizen.io ulegnie awarii, generowanie plików PDF w Twojej aplikacji przestanie działać.

  2. Kwestie związane z ochroną danych: Wrażliwe treści HTML — w tym dane klientów, raporty finansowe i dokumenty poufne — muszą być przesyłane do serwerów stron trzecich w celu przetworzenia.

  3. Opóźnienia sieciowe: Każde wygenerowanie pliku PDF powoduje opóźnienia w obie strony wynoszące 100–500 ms lub więcej, co znacznie wydłuża czas odpowiedzi aplikacji.

  4. Ceny na żądanie: Koszty rosną proporcjonalnie do wielkości wykorzystania, co sprawia, że generowanie dużej ilości plików PDF staje się coraz droższe.

  5. Ograniczanie szybkości: Ograniczanie przepustowości API w okresach dużego natężenia ruchu może powodować awarie lub opóźnienia w generowaniu plików PDF, gdy są one najbardziej potrzebne.

  6. Uzależnienie od dostawcy: ryzyko zmian w API lub zaprzestania świadczenia usług naraża aplikację na skutki zewnętrznych decyzji biznesowych.

Porównanie Kaizen.io i IronPDF

Funkcja Kaizen.io IronPDF
Przetwarzanie Chmura (serwery zewnętrzne) Lokalne (w trakcie przetwarzania)
Ochrona danych Dane przesyłane na zewnątrz Dane nigdy nie opuszczają Twojej infrastruktury
Opóźnienie Czas przesyłu w obie strony (100–500 ms+) Przetwarzanie lokalne (50–200 ms)
Dostępność Zależy od usługi zewnętrznej 100% kontroli w Twoich rękach
Ceny Na żądanie lub w ramach subskrypcji Licencja jednorazowa lub roczna
Tryb offline Niemożliwe Pełna funkcjonalność
Limity częstotliwości Ograniczanie przepustowości API Bez ograniczeń
JavaScript Ograniczone wsparcie Pełne wykonanie w Chromium

Dla zespołów planujących wdrożenie .NET 10 i C# 14 w latach 2025 i 2026,IronPDFzapewnia przyszłościową podstawę z lokalnym przetwarzaniem, która eliminuje zależność od usług zewnętrznych.

Ocena złożoności migracji

Szacowany nakład pracy według funkcji

Funkcja Złożoność migracji
Podstawowy HTML do PDF Bardzo niski
Plik HTML do PDF Bardzo niski
URL do pliku PDF Bardzo niski
Nagłówki/stopki Low
Ustawienia strony Bardzo niski
Zarządzanie kluczami API Low

Zmiana paradygmatu

Podstawową zmianą w tej migracji Kaizen.io jest przejście z wywołań API w chmurze na lokalne renderowanie w trakcie przetwarzania:

Kaizen.io:  HtmlToPdfConverter → Convert(html) → byte[] (przez sieć)
IronPDF:    ChromePdfRenderer → RenderHtmlAsPdf(html) → PdfDocument (lokalny)

Zanim zaczniesz

Wymagania wstępne

  1. Środowisko .NET: .NET Framework 4.6.2+ lub .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. Dostęp do NuGet: Możliwość instalowania pakietów NuGet
  3. Licencja IronPDF: Uzyskaj klucz licencyjny na stronie ironpdf.com

Zmiany w pakiecie NuGet

# Remove Kaizen.io package
dotnet remove package Kaizen.HtmlToPdf
dotnet remove package Kaizen.IO.HtmlToPdf

# Install IronPDF
dotnet add package IronPdf
# Remove Kaizen.io package
dotnet remove package Kaizen.HtmlToPdf
dotnet remove package Kaizen.IO.HtmlToPdf

# Install IronPDF
dotnet add package IronPdf
SHELL

Konfiguracja licencji

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Zidentyfikuj zastosowanie Kaizen.io

# Find all Kaizen.io references
grep -r "using Kaizen\|HtmlToPdfConverter\|ConversionOptions" --include="*.cs" .
grep -r "ConvertUrl\|ConvertHtml\|Kaizen" --include="*.cs" .
# Find all Kaizen.io references
grep -r "using Kaizen\|HtmlToPdfConverter\|ConversionOptions" --include="*.cs" .
grep -r "ConvertUrl\|ConvertHtml\|Kaizen" --include="*.cs" .
SHELL

Kompletna dokumentacija API

Mapowania klas

Klasa Kaizen.io OdpowiednikIronPDF
HtmlToPdfConverter ChromePdfRenderer
ConversionOptions ChromePdfRenderOptions
HeaderOptions HtmlHeaderFooter lub TextHeaderFooter
FooterOptions HtmlHeaderFooter lub TextHeaderFooter
PageSize PdfPaperSize
Orientation PdfPaperOrientation

Mapowanie metod

Metoda Kaizen.io OdpowiednikIronPDF
converter.Convert(html) renderer.RenderHtmlAsPdf(html)
converter.ConvertUrl(url) renderer.RenderUrlAsPdf(url)
File.WriteAllBytes(path, bytes) pdf.SaveAs(path)

Mapowania właściwości ConversionOptions

Właściwości Kaizen.io OdpowiednikIronPDF
PageSize RenderingOptions.PaperSize
Orientation RenderingOptions.PaperOrientation
MarginTop RenderingOptions.MarginTop
MarginBottom RenderingOptions.MarginBottom
Header.HtmlContent RenderingOptions.HtmlHeader.HtmlFragment
Footer.HtmlContent RenderingOptions.HtmlFooter.HtmlFragment

Mapowanie symboli zastępczych

Kaizen.io Miejsce na tekst IronPDF Placeholder
{page} {page}
{total} {total-pages}
{date} {date}
{title} {html-title}

Przykłady migracji kodu

Przykład 1: Podstawowy HTML do PDF

Przed (Kaizen.io):

using Kaizen.IO;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdfBytes = converter.Convert(html);
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
using Kaizen.IO;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdfBytes = converter.Convert(html);
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
Imports Kaizen.IO
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdfBytes = converter.Convert(html)
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Sub
End Class
$vbLabelText   $csharpLabel

Po (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
$vbLabelText   $csharpLabel

Podejście Kaizen.io tworzy HtmlToPdfConverter, wywołuje Convert() w celu uzyskania tablicy bajtów, a następnie ręcznie zapisuje bajty do pliku za pomocą File.WriteAllBytes(). Wymaga to dwukierunkowej komunikacji sieciowej z usługą chmurową Kaizen.io.

ChromePdfRenderer firmyIronPDFprzetwarza wszystko lokalnie. Metoda RenderHtmlAsPdf() zwraca obiekt PdfDocument z wygodną metodą SaveAs() — nie wymaga ręcznej obsługi tablicy bajtów ani nie powoduje opóźnień sieciowych. Dodatkowe opcje renderowania można znaleźć w dokumentacji dotyczącej konwersji HTML do PDF.

Przykład 2: Plik HTML do formatu PDF z ustawieniami strony

Przed (Kaizen.io):

using Kaizen.IO;
using System;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var htmlContent = File.ReadAllText("input.html");
        var options = new ConversionOptions
        {
            PageSize = PageSize.A4,
            Orientation = Orientation.Portrait
        };
        var pdfBytes = converter.Convert(htmlContent, options);
        File.WriteAllBytes("document.pdf", pdfBytes);
    }
}
using Kaizen.IO;
using System;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var htmlContent = File.ReadAllText("input.html");
        var options = new ConversionOptions
        {
            PageSize = PageSize.A4,
            Orientation = Orientation.Portrait
        };
        var pdfBytes = converter.Convert(htmlContent, options);
        File.WriteAllBytes("document.pdf", pdfBytes);
    }
}
Imports Kaizen.IO
Imports System
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim htmlContent = File.ReadAllText("input.html")
        Dim options = New ConversionOptions With {
            .PageSize = PageSize.A4,
            .Orientation = Orientation.Portrait
        }
        Dim pdfBytes = converter.Convert(htmlContent, options)
        File.WriteAllBytes("document.pdf", pdfBytes)
    End Sub
End Class
$vbLabelText   $csharpLabel

Po (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
$vbLabelText   $csharpLabel

Podejście Kaizen.io wymaga ręcznego odczytania zawartości pliku HTML za pomocą File.ReadAllText(), utworzenia oddzielnego obiektu ConversionOptions, przekazania obu do metody Convert(), a następnie ręcznego zapisania wynikowych bajtów do pliku.

IronPDF udostępnia dedykowaną metodę RenderHtmlFileAsPdf(), która odczytuje plik bezpośrednio — nie jest wymagany ręczny odczyt pliku. Konfiguracja jest ustawiona we właściwości RenderingOptions renderera, dzięki czemu wszystkie ustawienia znajdują się w jednym miejscu. Enumy PdfPaperSize.A4 i PdfPaperOrientation.Portrait odpowiadają bezpośrednio ich odpowiednikom z Kaizen.io.

Przykład 3: URL do pliku PDF z nagłówkami i stopkami

Przed (Kaizen.io):

using Kaizen.IO;
using System;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var options = new ConversionOptions
        {
            Header = new HeaderOptions { HtmlContent = "<div style='text-align:center'>Company Header</div>" },
            Footer = new FooterOptions { HtmlContent = "<div style='text-align:center'>Page {page} of {total}</div>" },
            MarginTop = 20,
            MarginBottom = 20
        };
        var pdfBytes = converter.ConvertUrl("https://example.com", options);
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
using Kaizen.IO;
using System;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var options = new ConversionOptions
        {
            Header = new HeaderOptions { HtmlContent = "<div style='text-align:center'>Company Header</div>" },
            Footer = new FooterOptions { HtmlContent = "<div style='text-align:center'>Page {page} of {total}</div>" },
            MarginTop = 20,
            MarginBottom = 20
        };
        var pdfBytes = converter.ConvertUrl("https://example.com", options);
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
Imports Kaizen.IO
Imports System
Imports System.IO

Module Program
    Sub Main()
        Dim converter As New HtmlToPdfConverter()
        Dim options As New ConversionOptions With {
            .Header = New HeaderOptions With {.HtmlContent = "<div style='text-align:center'>Company Header</div>"},
            .Footer = New FooterOptions With {.HtmlContent = "<div style='text-align:center'>Page {page} of {total}</div>"},
            .MarginTop = 20,
            .MarginBottom = 20
        }
        Dim pdfBytes = converter.ConvertUrl("https://example.com", options)
        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Sub
End Module
$vbLabelText   $csharpLabel

Po (IronPDF):

// 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
$vbLabelText   $csharpLabel

Ten przykład ilustruje kilka kluczowych różnic związanych z migracją. Kaizen.io wymaga zagnieżdżonych obiektów HeaderOptions i FooterOptions w obrębie ConversionOptions, z których każdy posiada właściwość HtmlContent.IronPDFzapewnia bardziej przejrzystą konfigurację TextHeader i TextFooter dzięki dedykowanym właściwościom CenterText, LeftText i RightText.

Uwaga: Składnia symboli zastępczych jest inna! Kaizen.io używa {total} do podania całkowitej liczby stron, natomiastIronPDFużywa {total-pages}. Jest to najczęstszy problem związany z migracją — przeszukaj swój kod źródłowy pod kątem {total} i zastąp go {total-pages}.

Metoda RenderUrlAsPdf() firmyIronPDFbezpośrednio renderuje dowolny adres URL z pełnym wykonaniem koduJavaScriptza pośrednictwem silnika Chromium — bez konieczności stosowania obejść. Dowiedz się więcej o konwersji adresów URL do formatu PDF oraz nagłówkach i stopkach.

Ważne uwagi dotyczące migracji

Zmiana składni symboli zastępczych

Najważniejszą zmianą podczas przenoszenia nagłówków i stopek jest składnia symboli zastępczych:

// Kaizen.io placeholders:
"Page {page} of {total}"

//IronPDFplaceholders:
"Page {page} of {total-pages}"
// Kaizen.io placeholders:
"Page {page} of {total}"

//IronPDFplaceholders:
"Page {page} of {total-pages}"
' Kaizen.io placeholders:
"Page {page} of {total}"

' IronPDF placeholders:
"Page {page} of {total-pages}"
$vbLabelText   $csharpLabel

Pełne mapowanie symboli zastępczych:

  • {page} → {page} (bez zmian)
  • {total} → {total-pages} (RÓŻNICA!)
  • {title} → {html-title} (RÓŻNICA!)
  • {date} → {date} (bez zmian)
  • {time} → {time} (bez zmian)

Zmiana typu zwracanej wartości

Kaizen.io zwraca bezpośrednio byte[].IronPDFzwraca obiekt PdfDocument:

// Kaizen.io returns byte[]
byte[] pdfBytes = converter.Convert(html);
File.WriteAllBytes("output.pdf", pdfBytes);

//IronPDFreturns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");           // Direct save
byte[] bytes = pdf.BinaryData;      // Or get bytes if needed
// Kaizen.io returns byte[]
byte[] pdfBytes = converter.Convert(html);
File.WriteAllBytes("output.pdf", pdfBytes);

//IronPDFreturns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");           // Direct save
byte[] bytes = pdf.BinaryData;      // Or get bytes if needed
' Kaizen.io returns byte()
Dim pdfBytes As Byte() = converter.Convert(html)
File.WriteAllBytes("output.pdf", pdfBytes)

' IronPDF returns PdfDocument
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")           ' Direct save
Dim bytes As Byte() = pdf.BinaryData ' Or get bytes if needed
$vbLabelText   $csharpLabel

Usuń zarządzanie kluczami API

Kaizen.io wymaga uwierzytelniania za pomocą klucza API dla każdego żądania.IronPDFwykorzystuje klucz licencyjny ustawiany jednorazowo podczas uruchamiania aplikacji:

// DELETE this Kaizen.io pattern:
var converter = new HtmlToPdfConverter("YOUR_API_KEY");

// IronPDF: Set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();  // No API key needed
// DELETE this Kaizen.io pattern:
var converter = new HtmlToPdfConverter("YOUR_API_KEY");

// IronPDF: Set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();  // No API key needed
' DELETE this Kaizen.io pattern:
Dim converter = New HtmlToPdfConverter("YOUR_API_KEY")

' IronPDF: Set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer = New ChromePdfRenderer()  ' No API key needed
$vbLabelText   $csharpLabel

Usuń obsługę błędów sieciowych

Usuń logikę ponownych prób, obsługę limitów częstotliwości i kod limitów czasu sieci —IronPDFprzetwarza dane lokalnie:

// DELETE this Kaizen.io pattern:
int retries = 3;
while (retries > 0)
{
    try
    {
        return converter.Convert(html);
    }
    catch (RateLimitException)
    {
        retries--;
        Thread.Sleep(1000);
    }
}

// IronPDF: Just call the method
return renderer.RenderHtmlAsPdf(html).BinaryData;
// DELETE this Kaizen.io pattern:
int retries = 3;
while (retries > 0)
{
    try
    {
        return converter.Convert(html);
    }
    catch (RateLimitException)
    {
        retries--;
        Thread.Sleep(1000);
    }
}

// IronPDF: Just call the method
return renderer.RenderHtmlAsPdf(html).BinaryData;
' DELETE this Kaizen.io pattern:
Dim retries As Integer = 3
While retries > 0
    Try
        Return converter.Convert(html)
    Catch ex As RateLimitException
        retries -= 1
        Thread.Sleep(1000)
    End Try
End While

' IronPDF: Just call the method
Return renderer.RenderHtmlAsPdf(html).BinaryData
$vbLabelText   $csharpLabel

Rozwiązywanie problemów

Problem 1: Nie znaleziono HtmlToPdfConverter

Problem: Klasa HtmlToPdfConverter nie istnieje w IronPDF.

Rozwiązanie: Zastąp przez ChromePdfRenderer:

// Kaizen.io
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
// Kaizen.io
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
' Kaizen.io
Dim converter As New HtmlToPdfConverter()

' IronPDF
Dim renderer As New ChromePdfRenderer()
$vbLabelText   $csharpLabel

Problem 2: Nie znaleziono opcji konwersji

Problem: Klasa ConversionOptions nie istnieje w IronPDF.

Rozwiązanie: Użyj RenderingOptions w rendererze:

// Kaizen.io
var options = new ConversionOptions { PageSize = PageSize.A4 };
converter.Convert(html, options);

// IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderHtmlAsPdf(html);
// Kaizen.io
var options = new ConversionOptions { PageSize = PageSize.A4 };
converter.Convert(html, options);

// IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderHtmlAsPdf(html);
' Kaizen.io
Dim options As New ConversionOptions With {.PageSize = PageSize.A4}
converter.Convert(html, options)

' IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Problem 3: Numery stron nie działają

Problem: W stopce wyświetla się dosłownie {total} zamiast liczby stron.

Rozwiązanie: Zaktualizuj składnię symboli zastępczych:

// Kaizen.io syntax (won't work)
"Page {page} of {total}"

//IronPDFsyntax
"Page {page} of {total-pages}"
// Kaizen.io syntax (won't work)
"Page {page} of {total}"

//IronPDFsyntax
"Page {page} of {total-pages}"
$vbLabelText   $csharpLabel

Problem 4: Nie znaleziono metody Convert

Problem: Metoda Convert() nie istnieje w ChromePdfRenderer.

Rozwiązanie: Użyj RenderHtmlAsPdf():

// Kaizen.io
var pdfBytes = converter.Convert(html);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);
var pdfBytes = pdf.BinaryData;
// Kaizen.io
var pdfBytes = converter.Convert(html);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);
var pdfBytes = pdf.BinaryData;
' Kaizen.io
Dim pdfBytes = converter.Convert(html)

' IronPDF
Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim pdfBytes = pdf.BinaryData
$vbLabelText   $csharpLabel

Problem 5: Powolne pierwsze renderowanie

Problem: Wygenerowanie pierwszego pliku PDF zajmuje 1–3 sekundy.

Rozwiązanie:IronPDFuruchamia Chromium przy pierwszym użyciu. Rozgrzewka przy uruchomieniu aplikacji:

// 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>")
$vbLabelText   $csharpLabel

Lista kontrolna migracji

Przed migracją

  • Zidentyfikuj wszystkie instrukcje Kaizen.io using
  • Dokument ConversionOptions użyte ustawienia
  • Zwróć uwagę na szablony nagłówków/stopek oraz symbole zastępcze
  • Wymień lokalizacje kluczy API (do usunięcia)
  • Sprawdź logikę ponownych prób/ograniczenia częstotliwości (do usunięcia)
  • Uzyskaj klucz licencyjny IronPDF

Zmiany w pakiecie

  • Usuń pakiet Kaizen.HtmlToPdf
  • Zainstaluj pakiet NuGet IronPdf: dotnet add package IronPdf
  • Zaktualizuj importy przestrzeni nazw

Zmiany w kodzie

  • Dodaj konfigurację klucza licencyjnego podczas uruchamiania
  • Zastąp HtmlToPdfConverter przez ChromePdfRenderer
  • Zamień ConversionOptions na RenderingOptions
  • Zaktualizuj Convert() na RenderHtmlAsPdf()
  • Zaktualizuj ConvertUrl() na RenderUrlAsPdf()
  • Zaktualizuj składnię symboli zastępczych ({total} → {total-pages})
  • Zastąp File.WriteAllBytes() przez pdf.SaveAs()
  • Usuń konfigurację klucza API
  • Usuń logikę ponownej próby/ograniczenia częstotliwości
  • Usunąć obsługę błędów sieciowych dla wywołań API

Testowanie

  • Przetestuj wszystkie ścieżki generowania plików PDF
  • Sprawdź renderowanie nagłówków/stopek
  • Sprawdź renderowanie symboli zastępczych
  • Sprawdź marginesy i rozmiary stron
  • Testowanie funkcjonalności w trybie offline (nowa funkcja!)
  • Poprawa wydajności w porównaniu z benchmarkami

Po migracji

  • Usuń klucz API Kaizen.io z konfiguracji
  • Aktualizacja zmiennych środowiskowych
  • Usuń konfigurację limitu szybkości
  • Monitorowanie aktualizacji/powiadomienia
Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie