Comment convertir Razor en PDF dans Blazor Server en utilisant C#

Les défis de l'API du conteneur

Kaizen.io HTML-to-PDF est un conteneur Docker avec une API v1.x délibérément petite, et l'intégration C# est ce que vous construisez vous-même par-dessus HttpClient. Cette configuration a de vraies limites en production :

1. Conteneur à faire fonctionner : Vous exécutez, surveillez et mettez à jour kaizenio.azurecr.io/html-to-pdf:latest quelque part accessible depuis votre application — Docker local, sidecar ou un hôte séparé.

2. Pas de SDK .NET : Chaque appel C# est fait manuellement HttpClient POST + JSON. Pas de IntelliSense, pas de vérifications à la compilation sur la forme de la requête.

3. Surface d'API très petite v1.x : Le corps JSON documenté n'accepte qu'un seul champ html. URL-vers-PDF, feuilles de style personnalisées, en-têtes/pieds de page, taille de page, orientation et marges sont listés comme éléments de la feuille de route plutôt que des fonctionnalités disponibles — tout ce qui dépasse le rendu d'une chaîne HTML doit être exprimé dans le HTML lui-même, généralement via @page CSS et divs positionnés absolument.

4. Pas de support pour les numéros de page : L'API ne dispose pas de {page}/ {total}espaces réservés, donc les pieds de page "Page X sur Y" ne peuvent pas être produits côté serveur.

5. Un aller-retour HTTP par PDF : Même lorsque le conteneur fonctionne sur localhost, chaque PDF paie la sérialisation JSON et un saut de socket.

6. Filigrane sur la version gratuite : Sans la variable d'environnement KAIZEN_PDF_LICENSE définie sur le conteneur, la sortie est marquée d'un filigrane.

Comparaison Kaizen.io vs IronPDF

Pour les équipes standardisant sur le .NET moderne,IronPDF supprime le conteneur sidecar et le saut HTTP de la requête tout en exposant une surface de configuration fortement typée.

Estimation de l'effort par fonctionnalité

Changement de paradigme

Le changement fondamental passe des appels HTTP hors processus à un conteneur Docker à un rendu dans le processus :

Kaizen.io:  HttpClient.PostAsync("http://.../html-to-pdf", { html }) → byte[]
IronPDF:    ChromePdfRenderer → RenderHtmlAsPdf(html) → PdfDocument

Prérequis

1. .NET Environment: .NET Framework 4.6.2+ or .NET Core 3.1+ / .NET 5+
2. Accès à NuGet : possibilité d'installer des packages NuGet
3. Licence IronPDF : Obtenez votre clé de licence sur IronPDF

Modifications du paquet

Il n'y a pas de package NuGet Kaizen à supprimer — Kaizen n'est livré que sous forme d'image Docker. Arrêtez le conteneur et ajoutez le package IronPDF:

# Stop and remove the running Kaizen container (if any)
docker stop kaizen-pdf
docker rm kaizen-pdf

# Install IronPDF
dotnet add package IronPdf

# Stop and remove the running Kaizen container (if any)
docker stop kaizen-pdf
docker rm kaizen-pdf

# Install IronPDF
dotnet add package IronPdf

Configuration de la licence

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

Identifier l'utilisation de Kaizen.io

Parce que Kaizen n'a pas de SDK, les appels s'y font comme des POST génériques HttpClient. Recherchez le point d'extrémité, le nom de l'image, et la variable d'environnement de la licence plutôt qu'un espace de noms :

grep -r "html-to-pdf\|KAIZEN_PDF_LICENSE\|kaizenio.azurecr.io\|localhost:8080" \
  --include="*.cs" --include="*.json" --include="*.yml" .

grep -r "html-to-pdf\|KAIZEN_PDF_LICENSE\|kaizenio.azurecr.io\|localhost:8080" \
  --include="*.cs" --include="*.json" --include="*.yml" .

Correspondances de concept

Il n'y a pas de classe .NET Kaizen à mapper — seulement la forme de la requête JSON et les conventions que vous avez bâties autour.

Mappages de caractères de substitution

Kaizen v1.x n'a pas de marque-places côté serveur. Si vous substituiez auparavant des chaînes dans le HTML avant de les envoyer en POST, passez aux marque-places de temps de rendu d'IronPDF :

Exemple 1 : HTML de base vers PDF

Avant (Kaizen.io — POST JSON au conteneur) :

// Container must be running:
//   docker run -d -p 8080:8080 -e KAIZEN_PDF_LICENSE=... \
//     kaizenio.azurecr.io/html-to-pdf:latest
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var http = new HttpClient();
        var payload = JsonSerializer.Serialize(new { html = "<html><body><h1>Hello World</h1></body></html>" });
        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await http.PostAsync("http://localhost:8080/html-to-pdf", content);
        response.EnsureSuccessStatusCode();
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

// Container must be running:
//   docker run -d -p 8080:8080 -e KAIZEN_PDF_LICENSE=... \
//     kaizenio.azurecr.io/html-to-pdf:latest
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var http = new HttpClient();
        var payload = JsonSerializer.Serialize(new { html = "<html><body><h1>Hello World</h1></body></html>" });
        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await http.PostAsync("http://localhost:8080/html-to-pdf", content);
        response.EnsureSuccessStatusCode();
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

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

Module Program
    Async Function Main() As Task
        Using http As New HttpClient()
            Dim payload = JsonSerializer.Serialize(New With {.html = "<html><body><h1>Hello World</h1></body></html>"})
            Dim content As New StringContent(payload, Encoding.UTF8, "application/json")
            Dim response = Await http.PostAsync("http://localhost:8080/html-to-pdf", content)
            response.EnsureSuccessStatusCode()
            Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
            File.WriteAllBytes("output.pdf", pdfBytes)
        End Using
    End Function
End Module

Aprè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

L'approche Kaizen.io sérialise JSON, le poste au point d'extrémité REST du conteneur, vérifie le code d'état, lit la réponse sous forme d'octets, et écrit ces octets sur le disque. L'exécution ChromePdfRenderer d'IronPDF se fait dans le processus — RenderHtmlAsPdf() renvoie un PdfDocument avec une méthode SaveAs(), donc l'aller-retour et la gestion manuelle des octets disparaissent. Voir la documentation HTML vers PDF pour des options de rendu supplémentaires.

Exemple 2 : Fichier HTML vers PDF avec paramètres de page

Kaizen v1.x n'a pas de point de terminaison de fichier et pas de champs de mise en page – vous lisez vous-même le fichier et vous intégrez la taille/orientation de la page dans @page CSS.

Avant (Kaizen.io):

using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var body = File.ReadAllText("input.html");
        var html = "<style>@page { size: A4 portrait; }</style>" + body;

        using var http = new HttpClient();
        var payload = JsonSerializer.Serialize(new { html });
        var response = await http.PostAsync(
            "http://localhost:8080/html-to-pdf",
            new StringContent(payload, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        File.WriteAllBytes("document.pdf", await response.Content.ReadAsByteArrayAsync());
    }
}

using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var body = File.ReadAllText("input.html");
        var html = "<style>@page { size: A4 portrait; }</style>" + body;

        using var http = new HttpClient();
        var payload = JsonSerializer.Serialize(new { html });
        var response = await http.PostAsync(
            "http://localhost:8080/html-to-pdf",
            new StringContent(payload, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        File.WriteAllBytes("document.pdf", await response.Content.ReadAsByteArrayAsync());
    }
}

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

Module Program
    Async Function Main() As Task
        Dim body = File.ReadAllText("input.html")
        Dim html = "<style>@page { size: A4 portrait; }</style>" & body

        Using http As New HttpClient()
            Dim payload = JsonSerializer.Serialize(New With {Key .html = html})
            Dim response = Await http.PostAsync(
                "http://localhost:8080/html-to-pdf",
                New StringContent(payload, Encoding.UTF8, "application/json"))
            response.EnsureSuccessStatusCode()
            File.WriteAllBytes("document.pdf", Await response.Content.ReadAsByteArrayAsync())
        End Using
    End Function
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

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;

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

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

RenderHtmlFileAsPdf() lit directement le fichier, et la taille et l'orientation de la page passent de CSS en ligne @page à des propriétés RenderingOptions.

Exemple 3 : URL vers PDF avec en-têtes et pieds de page

Kaizen v1.x n'a pas de ConvertUrl, pas de champs d'en-tête/pied de page, et pas d'espaces réservés pour les numéros de page. La solution de contournement consiste à récupérer vous-même la page et l'envelopper avec @page CSS et des divs à position fixe pour simuler l'en-tête/le pied de page — sans possibilité de rendus les numéros de page.

Avant (Kaizen.io):

using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var http = new HttpClient();
        var page = await http.GetStringAsync("https://example.com");
        var html = $@"<!doctype html><html><head><style>
            @page {{margin: 20mm;}}
            .h {{position: fixed; top: -15mm; left: 0; right: 0; text-align: center;}}
            .f {{position: fixed; bottom: -15mm; left: 0; right: 0; text-align: center;}}
        </style></head><body>
            <div class='h'>Company Header</div>
            <div class='f'>Footer (page numbers unsupported in Kaizen v1.x)</div>
            {page}
        </body></html>";

        var payload = JsonSerializer.Serialize(new { html });
        var response = await http.PostAsync(
            "http://localhost:8080/html-to-pdf",
            new StringContent(payload, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        File.WriteAllBytes("webpage.pdf", await response.Content.ReadAsByteArrayAsync());
    }
}

using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var http = new HttpClient();
        var page = await http.GetStringAsync("https://example.com");
        var html = $@"<!doctype html><html><head><style>
            @page {{margin: 20mm;}}
            .h {{position: fixed; top: -15mm; left: 0; right: 0; text-align: center;}}
            .f {{position: fixed; bottom: -15mm; left: 0; right: 0; text-align: center;}}
        </style></head><body>
            <div class='h'>Company Header</div>
            <div class='f'>Footer (page numbers unsupported in Kaizen v1.x)</div>
            {page}
        </body></html>";

        var payload = JsonSerializer.Serialize(new { html });
        var response = await http.PostAsync(
            "http://localhost:8080/html-to-pdf",
            new StringContent(payload, Encoding.UTF8, "application/json"));
        response.EnsureSuccessStatusCode();
        File.WriteAllBytes("webpage.pdf", await response.Content.ReadAsByteArrayAsync());
    }
}

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

Module Program
    Async Function Main() As Task
        Using http As New HttpClient()
            Dim page As String = Await http.GetStringAsync("https://example.com")
            Dim html As String = $"<!doctype html><html><head><style>
                @page {{margin: 20mm;}}
                .h {{position: fixed; top: -15mm; left: 0; right: 0; text-align: center;}}
                .f {{position: fixed; bottom: -15mm; left: 0; right: 0; text-align: center;}}
            </style></head><body>
                <div class='h'>Company Header</div>
                <div class='f'>Footer (page numbers unsupported in Kaizen v1.x)</div>
                {page}
            </body></html>"

            Dim payload As String = JsonSerializer.Serialize(New With {Key .html = html})
            Dim response As HttpResponseMessage = Await http.PostAsync(
                "http://localhost:8080/html-to-pdf",
                New StringContent(payload, Encoding.UTF8, "application/json"))
            response.EnsureSuccessStatusCode()
            File.WriteAllBytes("webpage.pdf", Await response.Content.ReadAsByteArrayAsync())
        End Using
    End Function
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

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;

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

Class Program
    Shared Sub Main()
        Dim 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
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

RenderUrlAsPdf() récupère et rend directement l'URL — pas de récupération de page côté client — et les divs simulés à position fixe sont remplacés par TextHeader / TextFooter zones. Les numéros de page sont produits via les espaces réservés {page}et {total-pages}, que Kaizen v1.x ne fournit pas. En savoir plus sur la conversion d'URL en PDF et les en-têtes et pieds de page.

La licence réside dans le code, pas dans le conteneur

La licence de Kaizen se configure via la variable d'environnement KAIZEN_PDF_LICENSE sur le conteneur Docker. La licence IronPDF est une propriété statique définie une fois au démarrage de l'application :

// DELETE the Kaizen container env var:
//   docker run ... -e KAIZEN_PDF_LICENSE=... kaizenio.azurecr.io/html-to-pdf

// IronPDF: set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

// DELETE the Kaizen container env var:
//   docker run ... -e KAIZEN_PDF_LICENSE=... kaizenio.azurecr.io/html-to-pdf

// IronPDF: set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

' DELETE the Kaizen container env var:
'   docker run ... -e KAIZEN_PDF_LICENSE=... kaizenio.azurecr.io/html-to-pdf

' IronPDF: set once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()

Syntaxe des marque-places

Si vous substituiez auparavant des chaînes dans le HTML avant de les envoyer en POST, passez aux marque-places de temps de rendu d'IronPDF :

• {page}(inchangé)
• {total}→ {total-pages}
• {title}→ {html-title}
• {date}→ {date}(inchangé)

Changement de type de retour

Kaizen renvoie des octets bruts sur HTTP.IronPDF renvoie un PdfDocument :

// Kaizen.io returns byte[] via HTTP
byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
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[] via HTTP
byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();
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

Imports System.IO

' Kaizen.io returns Byte() via HTTP
Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
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

Supprimer la plomberie HTTP

Une fois que le rendu est en processus, le code de support disparaît :

// DELETE all of:
// - HttpClient lifetime management
// - JSON serialization of { html }
// - response.EnsureSuccessStatusCode() / status-code branches
// - "container unreachable" retry/backoff
// - ReadAsByteArrayAsync()

// Replaced with a single in-process call:
var pdf = renderer.RenderHtmlAsPdf(html);

// DELETE all of:
// - HttpClient lifetime management
// - JSON serialization of { html }
// - response.EnsureSuccessStatusCode() / status-code branches
// - "container unreachable" retry/backoff
// - ReadAsByteArrayAsync()

// Replaced with a single in-process call:
var pdf = renderer.RenderHtmlAsPdf(html);

Problème 1 : Pas de classe HtmlToPdfConverter

Problème : Il n'y a pas de classe HtmlToPdfConverter à remplacer par — Kaizen n'a pas du tout de SDK .NET.

Solution : La migration se fait à partir de POST HttpClient contre le conteneur vers ChromePdfRenderer :

// Kaizen.io: hand-rolled HTTP
using var http = new HttpClient();
var response = await http.PostAsync("http://localhost:8080/html-to-pdf", content);

// IronPDF: in-process renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

// Kaizen.io: hand-rolled HTTP
using var http = new HttpClient();
var response = await http.PostAsync("http://localhost:8080/html-to-pdf", content);

// IronPDF: in-process renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

Imports System.Net.Http
Imports IronPdf

' Kaizen.io: hand-rolled HTTP
Using http As New HttpClient()
    Dim response = Await http.PostAsync("http://localhost:8080/html-to-pdf", content)
End Using

' IronPDF: in-process renderer
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

Problème 2 : Où est passé l'objet Options ?

Problème : Kaizen v1.x n'a pas de ConversionOptions — la mise en page des pages était en CSS en ligne @page, les en-têtes/pieds de page étaient des divs à position fixe.

Solution : Déplacer cette configuration vers RenderingOptions sur le moteur de rendu :

// Before: <style>@page { size: A4 portrait; margin: 20mm; }</style>
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;

// Before: <style>@page { size: A4 portrait; margin: 20mm; }</style>
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;

' Before: <style>@page { size: A4 portrait; margin: 20mm; }</style>
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20

Problème 3 : Les numéros de page ne se rendent pas

Problème : Kaizen v1.x n'a pas de support d'espaces réservés {page}/ {total}, donc tout pied de page "Page X sur Y" avant la migration était soit manquant soit un texte statique.

Solution : Utilisez les espaces réservés d'en-tête/pied de page d'IronPDF :

renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "Page {page} of {total-pages}"
};

renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "Page {page} of {total-pages}"
};

renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
    .CenterText = "Page {page} of {total-pages}"
}

Si vous remplaciez auparavant manuellement {total}dans votre propre code avant d'envoyer le POST, supprimez cette substitution —IronPDF résout {total-pages}au moment du rendu.

Problème 4 : Erreurs de connexion du conteneur

Problème : Les chemins de code gérant les erreurs "conteneur inaccessible" / port-8080.

Solution :IronPDF fonctionne en processus — il n'y a pas de point de connexion. Supprimer le traitement des erreurs de connexion.

Édition 5 : Premier rendu lent

Problème : La première génération du PDF prend 1 à 3 secondes.

Solution :IronPDF initialise Chromium lors de sa première utilisation. Réchauffement au démarrage de l'application :

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

Pré-migration

• Localisez chaque site d'appel de Kaizen (cherchez html-to-pdf, KAIZEN_PDF_LICENSE, kaizenio.azurecr.io, localhost:8080)
• Documentez le CSS en ligne @page utilisé pour la taille, l'orientation, les marges
• Documenter les faux divs d'en-tête/pied de page (position fixe avec décalages négatifs)
• Listez toute substitution de place-holders côté client (html.Replace("{page}", ...) etc.)
• Noter le cycle de vie du conteneur : tirer, exécuter, redémarrer, variable d'environnement de licence
• Obtenir une clé de licence IronPDF

Démontage du conteneur

• Arrêtez et supprimez le conteneur Kaizen en cours d'exécution (docker stop kaizen-pdf && docker rm kaizen-pdf)
• Supprimer les étapes de tirage / exécution de Kaizen du CI/CD
• Supprimez KAIZEN_PDF_LICENSE des secrets/env
• Installez le packageNuGet IronPdf(dotnet add package IronPdf)

Modifications du code

• Ajouter la configuration de la clé de licence au démarrage
• Remplacez le POST HttpClient par ChromePdfRenderer
• Déplacez le CSS intégré @page dans les propriétés RenderingOptions
• Remplacez le POST JSON par RenderHtmlAsPdf() / RenderHtmlFileAsPdf() / RenderUrlAsPdf()
• Remplacez les divs d'en-tête/pied de page simulés par TextHeader/Footer ou HtmlHeader/Footer
• Mettez à jour la syntaxe des espaces réservés ({total}→ {total-pages}, {title}→ {html-title})
• Remplacez le corps HTTP byte[] par pdf.BinaryData
• Utilisez pdf.SaveAs() au lieu de File.WriteAllBytes()
• Supprimer le traitement des erreurs de connectivité du conteneur et la gestion/rétentissement

Essai

• Tester tous les chemins de génération de PDF
• Vérifiez le rendu des en-têtes/pieds de page et les numéros de page (nouvelle capacité)
• Valider les marges, la taille de la page et l'orientation
• Tester le fonctionnement hors ligne (aucun conteneur requis)

Après la migration

• Démanteler l'infrastructure du conteneur Kaizen
• Mettre à jour les variables d'environnement / secrets
• Supprimer les vérifications de l'état des conteneurs de la surveillance/alerte
• Documenter les nouvelles erreurs de type exception typée