Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Guías de migración
  4. migración de kaizen.io a ironpdf
GUíAS DE MIGRACIóN

Cómo migrar de Kaizen.io a IronPDF en C#

Curtis Chau
Curtis Chau
Actualizado:

La migración de Kaizen.io HTML-to-PDF aIronPDFtransforma su flujo de trabajo PDF .NET de un servicio dependiente de la nube con latencia de red y problemas de privacidad de datos a una biblioteca local en proceso que mantiene sus datos dentro de su infraestructura. Esta guía proporciona una ruta de migración completa y paso a paso que elimina las dependencias de API externas y los precios por solicitud para desarrolladores .NET profesionales.

Por qué migrar de Kaizen.io a IronPDF

Los retos de las API basadas en la nube

Kaizen.io HTML-to-PDF, al igual que otros servicios PDF basados en la nube, introduce limitaciones que afectan a las aplicaciones de producción:

  1. Dependencia de la nube: requiere conexión constante a Internet y disponibilidad de servicios externos. Si el servicio de Kaizen.io experimenta un tiempo de inactividad, la generación de PDF de su aplicación deja de funcionar.

  2. Preocupaciones sobre la privacidad de los datos: el contenido HTML sensible (incluidos datos de clientes, informes financieros y documentos confidenciales) debe transmitirse a servidores de terceros para su procesamiento.

  3. Latencia de la red: cada generación de PDF genera retrasos en el viaje de ida y vuelta de entre 100 y 500 ms o más, lo que agrega una sobrecarga significativa a los tiempos de respuesta de su aplicación.

  4. Precios por solicitud: los costos se ajustan directamente con el volumen de uso, lo que hace que la generación de PDF en grandes volúmenes sea cada vez más costosa.

  5. Limitación de velocidad: la limitación de la API durante períodos de alto tráfico puede provocar fallas o demoras en la generación de PDF cuando más los necesita.

  6. Dependencia del proveedor: los cambios en la API o el riesgo de interrupción del servicio dejan su aplicación vulnerable a decisiones comerciales externas.

Comparación entre Kaizen.io y IronPDF

Característica Kaizen.io IronPDF
Procesamiento Nube (servidores externos) Local (en proceso)
Privacidad de datos Datos transmitidos externamente Los datos nunca salen de su infraestructura
Latencia Red de ida y vuelta (100-500ms+) Procesamiento local (50-200ms)
Disponibilidad Depende de un servicio externo 100% bajo su control
Precios Por solicitud o suscripción Licencia única o anual
Modo sin conexión No es posible Funcionalidad completa
Límites de tarifa Estrangulamiento de API Sin límites
JavaScript Asistencia limitada Ejecución completa de Chromium

Para los equipos que planifican la adopción de .NET 10 y C# 14 hasta 2025 y 2026,IronPDFproporciona una base preparada para el futuro con un procesamiento local que elimina las dependencias de servicios externos.

Evaluación de la complejidad de la migración

Esfuerzo estimado por función

Característica Complejidad de la migración
HTML básico a PDF Muy bajo
Archivo HTML a PDF Muy bajo
URL a PDF Muy bajo
Encabezados/pies de página Bajo
Configuración de la página Muy bajo
Gestión de claves API Bajo

Cambio de paradigma

El cambio fundamental en esta migración de Kaizen.io es de las llamadas API en la nube a la representación local en proceso:

Kaizen.io:  HtmlToPdfConverter → Convert(html) → byte[] (vía red)
IronPDF: ChromePdfRenderer → RenderHtmlAsPdf(html) → Documento PDF (local)

Antes de empezar

Prerrequisitos

  1. Entorno .NET : .NET Framework 4.6.2+ o .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. Acceso a NuGet : Capacidad para instalar paquetes NuGet
  3. Licencia deIronPDF: Obtenga su clave de licencia en IronPDF

Cambios en el paquete 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

Configuración de licencias

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

Identificar el uso de 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

Referencia completa de la API

Clases

Clase Kaizen.io Equivalente de IronPDF
HtmlToPdfConverter ChromePdfRenderer
ConversionOptions ChromePdfRenderOptions
HeaderOptions HtmlHeaderFooter o TextHeaderFooter
FooterOptions HtmlHeaderFooter o TextHeaderFooter
PageSize PdfPaperSize
Orientation PdfPaperOrientation

Métodos

Método Kaizen.io Equivalente de IronPDF
converter.Convert(html) renderer.RenderHtmlAsPdf(html)
converter.ConvertUrl(url) renderer.RenderUrlAsPdf(url)
File.WriteAllBytes(path, bytes) pdf.SaveAs(path)

Mapeo de propiedades de ConversionOptions

Propiedad de Kaizen.io Equivalente de IronPDF
PageSize RenderingOptions.PaperSize
Orientation RenderingOptions.PaperOrientation
MarginTop RenderingOptions.MarginTop
MarginBottom RenderingOptions.MarginBottom
Header.HtmlContent RenderingOptions.HtmlHeader.HtmlFragment
Footer.HtmlContent RenderingOptions.HtmlFooter.HtmlFragment

Mapeo de marcadores

Kaizen.io Marcador de posición Marcador de posición IronPDF
{page} {page}
{total} {total-pages}
{date} {date}
{title} {html-title}

Ejemplos de migración de código

Ejemplo 1: HTML básico a PDF

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

Después (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

El enfoque Kaizen.io crea un HtmlToPdfConverter, llama a Convert() para obtener una matriz de bytes y luego escribe manualmente los bytes en un archivo usando File.WriteAllBytes(). Esto implica un viaje de ida y vuelta en red al servicio en la nube de Kaizen.io.

El ChromePdfRenderer deIronPDFprocesa todo localmente. El método RenderHtmlAsPdf() devuelve un objeto PdfDocument con un método SaveAs() conveniente, sin necesidad de manejo manual de matrices de bytes y sin latencia de red. Consulte la documentación HTML a PDF para obtener más opciones de conversión.

Ejemplo 2: Archivo HTML a PDF con configuración de página

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

Después (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

El enfoque de Kaizen.io requiere leer manualmente el contenido del archivo HTML con File.ReadAllText(), crear un objeto ConversionOptions separado, pasar ambos al método Convert() y luego escribir manualmente los bytes del resultado en un archivo.

IronPDF proporciona un método dedicado RenderHtmlFileAsPdf() que lee el archivo directamente, sin necesidad de leerlo manualmente. La configuración se establece en la propiedad RenderingOptions del renderizador, manteniendo todas las configuraciones en un solo lugar. Las enumeraciones PdfPaperSize.A4 y PdfPaperOrientation.Portrait se asignan directamente desde los equivalentes de Kaizen.io.

Ejemplo 3: URL a PDF con encabezados y pies de página

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

Después (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

Este ejemplo muestra varias diferencias clave en la migración. Kaizen.io requiere objetos HeaderOptions y FooterOptions anidados dentro de ConversionOptions, cada uno con una propiedad HtmlContent.IronPDFproporciona una configuración más limpia de TextHeader y TextFooter con propiedades dedicadas CenterText, LeftText y RightText.

Nota crítica: ¡La sintaxis del marcador de posición es diferente! Kaizen.io usa {total} para el recuento total de páginas, mientras queIronPDFusa {total-pages}. Este es el problema de migración más común: busque en su base de código {total} y reemplácelo con {total-pages}.

El método RenderUrlAsPdf() deIronPDFprocesa directamente cualquier URL con ejecución completa de JavaScripta través del motor Chromium, sin necesidad de soluciones alternativas. Más información sobre conversión de URL a PDF y encabezados y pies de página.

Notas de migración críticas

Cambio en la sintaxis de los marcadores

El cambio más importante al migrar encabezados y pies de página es la sintaxis de los marcadores de posición:

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

Mapeo completo de marcadores de posición:

  • {page} → {page} (mismo)
  • {total} → {total-pages} (¡DIFERENTE!)
  • {title} → {html-title} (¡DIFERENTE!)
  • {date} → {date} (mismo)
  • {time} → {time} (mismo)

Cambio de tipo de retorno

Kaizen.io devuelve byte[] directamente.IronPDFdevuelve un objeto 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

Quitar la gestión de claves de API

Kaizen.io requiere autenticación de clave API por solicitud.IronPDFutiliza una clave de licencia que se establece una vez al iniciar la aplicación:

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

Borrar la gestión de errores de red

Elimine la lógica de reintento, la gestión del límite de velocidad y el código de tiempo de espera de la red:IronPDFprocesa localmente:

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

Solución de problemas

Asunto 1: HtmlToPdfConverter no encontrado

Problema: la clase HtmlToPdfConverter no existe en IronPDF.

Solución: Reemplazar con 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

Asunto 2: ConversionOptions Not Found

Problema: la clase ConversionOptions no existe en IronPDF.

Solución: utilice RenderingOptions en el renderizador:

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

Asunto 3: Los números de página no funcionan

Problema: el pie de página muestra el literal {total} en lugar del recuento de páginas.

Solución: Actualizar la sintaxis del marcador de posición:

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

Edición 4: Método de conversión no encontrado

Problema: el método Convert() no existe en ChromePdfRenderer.

Solución: Utilice 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

Número 5: Primera renderización lenta

Problema: la primera generación de PDF tarda entre 1 y 3 segundos.

Solución:IronPDFinicializa Chromium en el primer uso. Calentamiento al inicio de la aplicación:

// 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 de comprobación de la migración

Pre-Migración

  • Identificar todas las declaraciones de Kaizen.io using
  • Documento ConversionOptions configuraciones utilizadas
  • Plantillas de encabezado/pie de página y marcadores de posición de notas
  • Lista de ubicaciones de claves API (para eliminar)
  • Verificar la lógica de reintento/límite de velocidad (para eliminar)
  • Obtener la clave de licencia de IronPDF

Cambios en el paquete

  • Eliminar el paquete Kaizen.HtmlToPdf
  • Instalar IronPdf el paquete NuGet : dotnet add package IronPdf
  • Actualizar las importaciones de espacios de nombres

Cambios de código

  • Agregar configuración de clave de licencia al inicio
  • Reemplace HtmlToPdfConverter con ChromePdfRenderer
  • Convertir ConversionOptions a RenderingOptions
  • Actualizar Convert() a RenderHtmlAsPdf()
  • Actualizar ConvertUrl() a RenderUrlAsPdf()
  • Actualizar la sintaxis del marcador de posición ({total} → {total-pages})
  • Reemplace File.WriteAllBytes() con pdf.SaveAs()
  • Eliminar la configuración de la clave API
  • Eliminar la lógica de reintento/límite de velocidad
  • Eliminar el manejo de errores de red para llamadas API

Pruebas

  • Probar todas las rutas de generación de PDF
  • Verificar la representación del encabezado/pie de página
  • Verificar la representación del marcador de posición
  • Validar márgenes y tamaños de página
  • Pruebe la funcionalidad sin conexión (¡nueva capacidad!)
  • Mejora del rendimiento de referencia

Posmigración

  • Eliminar la clave API de Kaizen.io de la configuración
  • Actualizar las variables de entorno
  • Eliminar la configuración del límite de velocidad
  • Monitoreo/alerta de actualizaciones
Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame