Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von kaizen.io zu IronPDF
MIGRATIONSLEITFäDEN

Wie man von Kaizen.io zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

Die Migration von Kaizen.io HTML-to-PDF zu IronPDF verwandelt Ihren .NET-PDF-Workflow von einem Cloud-abhängigen Dienst mit Netzwerklatenz und Datenschutzbedenken in eine lokale prozessinterne Bibliothek, die Ihre Daten innerhalb Ihrer Infrastruktur hält. Dieser Leitfaden bietet einen umfassenden, schrittweisen Migrationspfad, der externe API-Abhängigkeiten und Preise pro Anfrage für professionelle .NET-Entwickler eliminiert.

Warum von Kaizen.io zu IronPDF migrieren

Die Herausforderungen der Cloud-basierten API

Kaizen.io HTML-to-PDF unterliegt wie andere Cloud-basierte PDF-Dienste Einschränkungen, die sich auf Produktionsanwendungen auswirken:

  1. Cloud-Abhängigkeit: Erfordert eine ständige Internetverbindung und die Verfügbarkeit externer Dienste. Wenn der Kaizen.io-Dienst ausfällt, funktioniert die PDF-Generierung in Ihrer Anwendung nicht mehr.

  2. Datenschutzbedenken: Sensible HTML-Inhalte – einschließlich Kundendaten, Finanzberichte und vertrauliche Dokumente – müssen zur Verarbeitung an Server von Drittanbietern übermittelt werden.

  3. Netzwerklatenz: Jede PDF-Generierung verursacht Netzwerk-Roundtrip-Verzögerungen von 100-500 ms oder mehr, was die Antwortzeiten Ihrer Anwendung erheblich verlängert.

  4. Preisgestaltung pro Anfrage: Die Kosten steigen direkt mit dem Nutzungsvolumen, wodurch die Erstellung großer Mengen von PDFs zunehmend teurer wird.

  5. Ratenbegrenzung: Die Drosselung der API während Zeiten mit hohem Datenverkehr kann zu Fehlern oder Verzögerungen bei der PDF-Generierung führen, gerade dann, wenn Sie die PDFs am dringendsten benötigen.

  6. Abhängigkeit von einem Anbieter: Änderungen an der API oder die Einstellung von Dienstleistungen bergen das Risiko, dass Ihre Anwendung von externen Geschäftsentscheidungen abhängig wird.

Kaizen.io vs IronPDFVergleich

Feature Kaizen.io IronPDF
Verarbeitung Cloud (externe Server) Lokal (in Bearbeitung)
Datenschutz Extern übermittelte Daten Daten verlassen nie Ihre Infrastruktur
Latenzzeit Netzwerk-Round-Trip (100-500ms+) Lokale Verarbeitung (50-200ms)
Verfügbarkeit Abhängig von einem externen Dienst 100% unter Ihrer Kontrolle
Preisgestaltung Pro Anfrage oder Abonnement Einmalige oder jährliche Lizenz
Offline-Modus Nicht möglich Volle Funktionalität
Preisgrenzen API-Drosselung Keine Grenzen
JavaScript Begrenzte Unterstützung Vollständige Ausführung von Chromium

Für Teams, die die Einführung von .NET 10 und C# 14 bis 2025 und 2026 planen, bietet IronPDF eine zukunftssichere Grundlage mit lokaler Verarbeitung, die Abhängigkeiten von externen Diensten eliminiert.

Migrationskomplexitätsbewertung

Geschätzter Aufwand nach Merkmalen

Feature Komplexität der Migration
Grundlegendes HTML zu PDF Sehr niedrig
HTML-Datei in PDF Sehr niedrig
URL zu PDF Sehr niedrig
Kopf-/Fußzeilen Niedrig
Seite Einstellungen Sehr niedrig
API-Schlüsselverwaltung Niedrig

Paradigmen-Verschiebung

Der grundlegende Shift bei dieser Kaizen.io-Migration besteht in der Umstellung von Cloud-API-Aufrufen auf lokales In-Process-Rendering:

Kaizen.io:  HtmlToPdfConverter → Convert(html) → byte[] (via Netzwerk)
IronPDF:    ChromePdfRenderer → RenderHtmlAsPdf(html) → PdfDocument (lokal)

Bevor Sie beginnen

Voraussetzungen

  1. .NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
  3. IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

# 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

Lizenz-Konfiguration

// 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

Kaizen.io-Verwendung identifizieren

# 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

Komplette API-Referenz

Klassen-Zuordnungen

Kaizen.io Klasse IronPDF-Äquivalent
HtmlToPdfConverter ChromePdfRenderer
ConversionOptions ChromePdfRenderOptions
HeaderOptions HtmlHeaderFooter oder TextHeaderFooter
FooterOptions HtmlHeaderFooter oder TextHeaderFooter
PageSize PdfPaperSize
Orientation PdfPaperOrientation

Methoden-Zuordnungen

Kaizen.io-Methode IronPDF-Äquivalent
converter.Convert(html) renderer.RenderHtmlAsPdf(html)
converter.ConvertUrl(url) renderer.RenderUrlAsPdf(url)
File.WriteAllBytes(path, bytes) pdf.SaveAs(path)

ConversionOptions-Eigenschaftszuordnungen

Kaizen.io Eigenschaft IronPDF-Äquivalent
PageSize RenderingOptions.PaperSize
Orientation RenderingOptions.PaperOrientation
MarginTop RenderingOptions.MarginTop
MarginBottom RenderingOptions.MarginBottom
Header.HtmlContent RenderingOptions.HtmlHeader.HtmlFragment
Footer.HtmlContent RenderingOptions.HtmlFooter.HtmlFragment

Platzhalter-Zuordnungen

Kaizen.io Platzhalter IronPDFPlatzhalter
{page} {page}
{total} {total-pages}
{date} {date}
{title} {html-title}

Beispiele für die Code-Migration

Beispiel 1: Grundlegendes HTML zu PDF

Vor (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

Nach (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

Der Kaizen.io-Ansatz erstellt ein HtmlToPdfConverter, ruft Convert() auf, um ein Byte-Array zu erhalten, und schreibt dann die Bytes manuell mit File.WriteAllBytes() in eine Datei. Dies beinhaltet einen Netzwerk-Roundtrip zum Kaizen.io Cloud-Service.

IronPDF's ChromePdfRenderer verarbeitet alles lokal. Die Methode RenderHtmlAsPdf() gibt ein PdfDocument-Objekt mit einer praktischen SaveAs()-Methode zurück – es ist keine manuelle Byte-Array-Verarbeitung erforderlich und es entstehen keine Netzwerkverzögerungen. Weitere Rendering-Optionen finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: HTML-Datei in PDF mit Seiteneinstellungen

Vor (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

Nach (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

Der Kaizen.io-Ansatz erfordert das manuelle Einlesen des HTML-Dateiinhalts mit File.ReadAllText(), das Erstellen eines separaten ConversionOptions-Objekts, das Übergeben beider an die Methode Convert() und das anschließende manuelle Schreiben der Ergebnisbytes in eine Datei.

IronPDF bietet eine spezielle Methode RenderHtmlFileAsPdf(), die die Datei direkt liest – manuelles Lesen der Datei ist nicht erforderlich. Die Konfiguration wird über die RenderingOptions-Eigenschaft des Renderers festgelegt, sodass alle Einstellungen an einem Ort gespeichert werden. Die Enumerationen PdfPaperSize.A4 und PdfPaperOrientation.Portrait werden direkt von den entsprechenden Werten in Kaizen.io übernommen.

Beispiel 3: URL in PDF mit Kopf- und Fußzeilen

Vor (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

Nach (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

Dieses Beispiel verdeutlicht mehrere wichtige Migrationsunterschiede. Kaizen.io benötigt verschachtelte HeaderOptions und FooterOptions Objekte innerhalb von ConversionOptions, jedes mit einer HtmlContent Eigenschaft.IronPDF bietet eine übersichtlichere TextHeader- und TextFooter-Konfiguration mit dedizierten CenterText-, LeftText- und RightText-Eigenschaften.

Wichtiger Hinweis: Die Syntax für die Platzhalter ist unterschiedlich! Kaizen.io verwendet {total} für die Gesamtzahl der Seiten, während IronPDF{total-pages} verwendet. Dies ist das häufigste Migrationsproblem – suchen Sie in Ihrer Codebasis nach {total} und ersetzen Sie es durch {total-pages}.

Die Methode RenderUrlAsPdf() von IronPDF rendert jede URL direkt mit vollständiger JavaScriptAusführung über die Chromium-Engine – ohne dass Umwege erforderlich sind. Erfahren Sie mehr über URL in PDF-Konvertierung und Kopf- und Fußzeilen.

Kritische Hinweise zur Migration

Änderung der Syntax für Platzhalter

Die wichtigste Änderung bei der Migration von Kopf- und Fußzeilen ist die Syntax der Platzhalter:

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

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

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

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

Komplette Platzhalterzuordnung:

  • {page} → {page} (dasselbe)
  • {total} → {total-pages} (ANDERS!)
  • {title} → {html-title} (ANDERS!)
  • {date} → {date} (dasselbe)
  • {time} → {time} (dasselbe)

Rückgabetyp ändern

Kaizen.io gibt byte[] direkt zurück.IronPDF gibt ein PdfDocument-Objekt zurück:

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

//IronPDF returns 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);

//IronPDF returns 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

Entfernen Sie die API-Schlüsselverwaltung

Kaizen.io erfordert eine Authentifizierung mit API-Schlüssel pro Anfrage.IronPDF verwendet einen Lizenzschlüssel, der einmalig beim Start der Anwendung festgelegt wird:

// 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

Löschen der Netzwerk-Fehlerbehandlung

Entfernen Sie die Logik für Wiederholungsversuche, die Handhabung von Ratenbegrenzungen und den Timeout-Code im Netzwerk -IronPDF wird lokal verarbeitet:

// 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

Fehlerbehebung

Ausgabe 1: HtmlToPdfConverter nicht gefunden

Problem: Die Klasse HtmlToPdfConverter existiert nicht in IronPDF.

Lösung: Ersetzen Sie durch 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

Ausgabe 2: ConversionOptions nicht gefunden

Problem: Die Klasse ConversionOptions existiert nicht in IronPDF.

Lösung: Verwenden Sie RenderingOptions auf dem Renderer:

// 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: Nicht funktionierende Seitenzahlen

Problem: In der Fußzeile wird anstelle der Seitenzahl das Wort {total} angezeigt.

Lösung: Aktualisieren Sie die Syntax des Platzhalters:

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

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

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

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

Ausgabe 4: Konvertierungsmethode nicht gefunden

Problem: Die Methode Convert() existiert nicht in ChromePdfRenderer.

Lösung: Verwenden Sie 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

Ausgabe 5: Erstes Rendering langsam

Problem: Die erste PDF-Generierung dauert 1-3 Sekunden.

Lösung:IronPDF initialisiert Chromium bei der ersten Verwendung. Aufwärmen beim Starten der Anwendung:

// 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

Migrations-Checkliste

Vor der Migration

  • Identifizieren Sie alle Kaizen.io using-Anweisungen
  • Dokument ConversionOptions Einstellungen verwendet
  • Kopf-/Fußzeilenvorlagen und Platzhalter
  • Liste der API-Schlüsselspeicherorte (zum Entfernen)
  • Überprüfung der Wiederholungs-/Ratenbegrenzungslogik (zum Löschen) -IronPDF-Lizenzschlüssel erhalten

Paketänderungen

  • Entfernen Sie das Paket Kaizen.HtmlToPdf
  • Installieren Sie das NuGet Paket IronPdf: dotnet add package IronPdf
  • Namespace-Importe aktualisieren

Code-Änderungen

  • Lizenzschlüsselkonfiguration beim Start hinzufügen
  • Ersetzen Sie HtmlToPdfConverter durch ChromePdfRenderer
  • Konvertiere ConversionOptions in RenderingOptions
  • Aktualisierung von Convert() auf RenderHtmlAsPdf()
  • Aktualisierung von ConvertUrl() auf RenderUrlAsPdf()
  • Aktualisierung der Platzhaltersyntax ({total} → {total-pages})
  • Ersetzen Sie File.WriteAllBytes() durch pdf.SaveAs()
  • API-Schlüsselkonfiguration entfernen
  • Wiederholungs-/Ratenbegrenzungslogik löschen
  • Entfernen der Netzwerkfehlerbehandlung für API-Aufrufe

Testen

  • Alle PDF-Generierungspfade testen
  • Überprüfung der Darstellung von Kopf- und Fußzeile
  • Platzhalterdarstellung prüfen
  • Ränder und Seitengrößen überprüfen
  • Offline-Funktionalität testen (neue Funktion!)
  • Verbesserung der Benchmark-Leistung

Nach der Migration

  • Entfernen Sie den Kaizen.io-API-Schlüssel aus der Konfiguration
  • Umgebungsvariablen aktualisieren
  • Ratenbegrenzungskonfiguration entfernen
  • Aktualisierungsüberwachung/Alarmierung
Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an