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
Veröffentlicht:

Die Migration von Kaizen.io HTML-to-PDF zuIronPDFverwandelt 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 zuIronPDFmigrieren

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 vsIronPDFVergleich

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, bietetIronPDFeine zukunftssichere Grundlage mit lokaler Verarbeitung, die Abhängigkeiten von externen Diensten eliminiert.

Migrationskomplexitätsbewertung

Geschätzter Aufwand nach Merkmalen

Feature Komplexität der Migration Notizen
Grundlegendes HTML zu PDF Sehr niedrig Direkte Methodenersetzung
HTML-Datei in PDF Sehr niedrig Direkte Methodenersetzung
URL zu PDF Sehr niedrig Direkte Methodenersetzung
Kopf-/Fußzeilen Niedrig Änderung der Platzhalter-Syntax
Seite Einstellungen Sehr niedrig Eigenschaften-Zuordnung
API-Schlüsselverwaltung Niedrig Vollständig löschen

Paradigmen-Verschiebung

Der grundlegende Wandel 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 auf ironpdf.com.

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";
$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 Notizen
HtmlToPdfConverter ChromePdfRenderer Hauptkonverter
Konvertierungsoptionen ChromePdfRenderOptions Über RenderingOptions
Kopfzeilen-Optionen HtmlHeaderFooter oder TextHeaderFooter HTML/Text-Kopfzeilen
FooterOptions HtmlHeaderFooter oder TextHeaderFooter HTML/Text-Fußzeilen
Seitengröße PdfPaperSize Papierformat enum
Ausrichtung PdfPaperOrientierung Orientierung enum

Methoden-Zuordnungen

Kaizen.io-Methode IronPDF-Äquivalent Notizen
converter.Convert(html) renderer.RenderHtmlAsPdf(html) Liefert PdfDocument
converter.ConvertUrl(url) renderer.RenderUrlAsPdf(url) Direkte URL-Unterstützung
File.WriteAllBytes(Pfad, Bytes) pdf.SaveAs(Pfad) Direkte Speichermethode

ConversionOptions-Eigenschaftszuordnungen

Kaizen.io Eigenschaft IronPDF-Äquivalent Notizen
Seitengröße RenderingOptions.PaperSize Enum-Wert
Ausrichtung RenderingOptions.PaperOrientation Porträt/Landschaft
MarginTop RenderingOptions.MarginTop In Millimetern
MarginBottom RenderingOptions.MarginBottom In Millimetern
Header.HtmlContent RenderingOptions.HtmlHeader.HtmlFragment Kopfzeile HTML
Footer.HtmlContent RenderingOptions.HtmlFooter.HtmlFragment Fußzeile HTML

Platzhalter-Zuordnungen

Kaizen.io Platzhalter IronPDFPlatzhalter Notizen
{Seite} {Seite} Aktuelle Seite (gleich)
{Gesamtbetrag} {Gesamtseiten} Seiten insgesamt (unterschiedlich!)
{Datum} {Datum} Aktuelles Datum (gleich)
{Titel} {html-title} Titel des Dokuments (anders!)

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

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

Der ChromePdfRenderervonIronPDFverarbeitet alles lokal. Die RenderHtmlAsPdf()-Methode gibt ein PdfDocument-Objekt mit einer praktischen SaveAs()-Methode zurück - ohne manuelle Handhabung von Byte-Arrays und ohne Netzwerklatenz. 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);
    }
}
$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");
    }
}
$vbLabelText   $csharpLabel

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

IronPDF bietet eine spezielle RenderHtmlFileAsPdf()-Methode, die die Datei direkt liest - ein manuelles Einlesen der Datei ist nicht erforderlich. Die Konfiguration wird über die RenderingOptions-Eigenschaft des Renderers festgelegt, so dass alle Einstellungen an einem Ort bleiben. Die Enums PdfPaperSize.A4 und PdfPaperOrientation.Portrait werden direkt von den Äquivalenten von 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);
    }
}
$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");
    }
}
$vbLabelText   $csharpLabel

Dieses Beispiel verdeutlicht mehrere wichtige Migrationsunterschiede. Kaizen.io benötigt verschachtelte Kopfzeilen-Optionenund FooterOptionsObjekte innerhalb von ConversionOptions, jeweils mit einer HtmlContent Eigenschaft.IronPDFbietet 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 {Gesamtbetrag}für die Gesamtseitenzahl, währendIronPDF{Gesamtseiten}verwendet. Dies ist das häufigste Migrationsproblem - suchen Sie in Ihrer Codebasis nach {Gesamtbetrag}und ersetzen Sie es durch {total-pages}.

Die RenderUrlAsPdf()-Methode vonIronPDFrendert jede URL direkt mit vollständiger JavaScript-Ausführung über die Chromium-Engine - es sind keine Umgehungslösungen erforderlich. 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}"

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

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

Komplette Platzhalterzuordnung:

  • {Seite} → {Seite} (gleich)
  • {Gesamt} → {Gesamtseiten} (UNTERSCHIEDLICH!)
  • {Titel}→ {html-title}(UNTERSCHIEDLICH!)
  • {Datum} → {Datum} (gleich)
  • {zeit} → {zeit} (gleich)

Rückgabetyp ändern

Kaizen.io gibt Byte[] direkt zurück.IronPDFgibt ein PdfDocument-Objekt zurück:

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

Entfernen Sie die API-Schlüsselverwaltung

Kaizen.io erfordert eine Authentifizierung mit API-Schlüssel pro Anfrage.IronPDFverwendet 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
$vbLabelText   $csharpLabel

Löschen der Netzwerk-Fehlerbehandlung

Entfernen Sie die Logik für Wiederholungsversuche, die Handhabung von Ratenbegrenzungen und den Timeout-Code im Netzwerk -IronPDFwird 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;
$vbLabelText   $csharpLabel

Fehlerbehebung

Ausgabe 1: HtmlToPdfConverter nicht gefunden

Problem: Die Klasse HtmlToPdfConverterexistiert inIronPDFnicht.

Lösung: Ersetzen Sie dies durch ChromePdfRenderer:

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

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

// IronPDF
var renderer = new ChromePdfRenderer();
$vbLabelText   $csharpLabel

Ausgabe 2: ConversionOptions nicht gefunden

Problem: Die Klasse Konvertierungsoptionenexistiert inIronPDFnicht.

Lösung: Verwenden Sie RenderingOptions für den 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);
$vbLabelText   $csharpLabel

Problem 3: Nicht funktionierende Seitenzahlen

Problem: In der Fußzeile wird die Zahl {Gesamtbetrag}anstelle der Seitenzahl angezeigt.

Lösung: Aktualisieren Sie die Syntax des Platzhalters:

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

Ausgabe 4: Konvertierungsmethode nicht gefunden

Problem: Convert() -Methode existiert nicht für 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;
$vbLabelText   $csharpLabel

Ausgabe 5: Erstes Rendering langsam

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

Lösung:IronPDFinitialisiert 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>");
$vbLabelText   $csharpLabel

Migrations-Checkliste

Vor der Migration

  • Identifizieren Sie alle Kaizen.io using -Anweisungen
  • verwendete Einstellungen für die ConversionOptions
  • 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 IronPdf NuGet-Paket: dotnet add package IronPdf
  • Namespace-Importe aktualisieren

Code-Änderungen

  • Lizenzschlüsselkonfiguration beim Start hinzufügen
  • Ersetzen Sie HtmlToPdfConverterdurch ChromePdfRenderer
  • Konvertierung Konvertierungsoptionenin RenderingOptions
  • Aktualisieren Sie Convert() auf RenderHtmlAsPdf()
  • Aktualisieren Sie ConvertUrl() auf RenderUrlAsPdf()
  • Aktualisierung der Platzhaltersyntax ( {Gesamtbetrag}→ {Gesamtseiten})
  • 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