Comment déboguer HTML dans Chrome pour créer des PDFs pixel parfaits

Considération de la licence AGPL

iText (appartenant à iText Group / Apryse Group NV) a des caractéristiques de licence que les équipes commerciales devraient peser dès le départ :

1. Licence virale AGPL : Si vous utilisez iText sous sa licence open-source dans une application web, l'AGPL est généralement interprété comme vous obligeant à publier le code source de votre application à toute personne interagissant avec elle via un réseau. Pour les logiciels commerciaux à code fermé, cela signifie généralement l'achat d'une licence commerciale à la place.

2. Licence commerciale par abonnement uniquement : La licence commerciale d'iText est vendue sous forme d'abonnement annuel basé sur le volume de traitement des PDF ; une option perpétuelle n'est pas annoncée sur la page de tarification publique (les termes OEM personnalisés sont sur devis uniquement).

3. Coût de l'extension pdfHTML : La conversion HTML-en-PDF nécessite l'extension itext.pdfhtml (actuellement 6.3.2), vendue séparément en plus du paquetage principal itext (actuellement 9.6.0).

4. Audits de licence complexes : Les déploiements Enterprise font face à une complexité de licence et à un risque d'audit.

5. API orientée programme : iText de base crée des PDF en composant des objets Paragraph, Table et Cell dans le code ; pdfHTML vous permet de commencer à partir de HTML.

6. Sous-ensemble CSS défini, pas de JS au moment du rendu : pdfHTML prend en charge un sous-ensemble défini de CSS et n'exécute pas JavaScript lors de la conversion HTML en PDF (les actions de formulaire JS au niveau PDF sont une fonctionnalité séparée et prise en charge).

Comparaison entre IronPDF et iText

Pour les équipes se standardisant sur .NET moderne, l'approche HTML-first d'IronPDF s'appuie sur les compétences en développement web que l'équipe possède déjà.

Estimation de l'effort par fonctionnalité

Changement de paradigme

Le Shift fondamental de cette migration iText réside dans le passage de la construction de PDF par programmation à un rendu privilégiant le HTML :

iText :    PdfWriter → PdfDocument → Document → Add(Paragraph) → Add(Table)
IronPDF :  ChromePdfRenderer → RenderHtmlAsPdf(htmlString) → SaveAs()

Ce changement de paradigme est libérateur : au lieu d'apprendre le modèle d'objet d'iText, vous utilisez les compétences HTML et CSS que les développeurs web possèdent déjà.

Prérequis

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

Modifications du paquet NuGet

# Remove iText packages (current naming is 'itext'; 'itext7' is the deprecated alias)
dotnet remove package itext
dotnet remove package itext.pdfhtml
dotnet remove package itext7
dotnet remove package itext7.pdfhtml
dotnet remove package itextsharp

# Install IronPDF
dotnet add package IronPdf

# Remove iText packages (current naming is 'itext'; 'itext7' is the deprecated alias)
dotnet remove package itext
dotnet remove package itext.pdfhtml
dotnet remove package itext7
dotnet remove package itext7.pdfhtml
dotnet remove package itextsharp

# 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 d'iText

# Find all iText references
grep -r "using iText\|using iTextSharp" --include="*.cs" .
grep -r "PdfWriter\|PdfDocument\|Document\|Paragraph\|Table\|Cell" --include="*.cs" .
grep -r "HtmlConverter\|ConverterProperties" --include="*.cs" .

# Find all iText references
grep -r "using iText\|using iTextSharp" --include="*.cs" .
grep -r "PdfWriter\|PdfDocument\|Document\|Paragraph\|Table\|Cell" --include="*.cs" .
grep -r "HtmlConverter\|ConverterProperties" --include="*.cs" .

Mappages de classes

Mappages d'espaces de noms

Exemple 1 : Conversion HTML vers PDF

Avant (iText) :

// NuGet: Install-Package itext7
using iText.Html2pdf;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";
        string outputPath = "output.pdf";

        using (FileStream fs = new FileStream(outputPath, FileMode.Create))
        {
            HtmlConverter.ConvertToPdf(html, fs);
        }
    }
}

// NuGet: Install-Package itext7
using iText.Html2pdf;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";
        string outputPath = "output.pdf";

        using (FileStream fs = new FileStream(outputPath, FileMode.Create))
        {
            HtmlConverter.ConvertToPdf(html, fs);
        }
    }
}

Imports iText.Html2pdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim html As String = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
        Dim outputPath As String = "output.pdf"

        Using fs As FileStream = New FileStream(outputPath, FileMode.Create)
            HtmlConverter.ConvertToPdf(html, fs)
        End Using
    End Sub
End Class

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

L'approche iText nécessite le paquetage séparé itext.pdfhtml (extension pdfHTML, actuellement 6.3.2, vendu séparément en plus de itext 9.6.0), en créant un FileStream et en enveloppant tout dans des déclarations using pour l'élimination appropriée. La méthode HtmlConverter.ConvertToPdf() écrit directement dans le flux.

L'approche d'IronPDF est plus propre : créez un ChromePdfRenderer, appelez RenderHtmlAsPdf() avec votre chaîne HTML, et appelez SaveAs() sur le PdfDocument résultant. Il n'y a pas de paquets séparés, pas de gestion de flux, et le moteur de rendu Chromium fournit un support CSS3 et JavaScript supérieur. Voir la documentation HTML vers PDF pour des options de rendu supplémentaires.

Exemple 2 : fusionner plusieurs PDF

Avant (iText) :

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Kernel.Utils;
using System.IO;

class Program
{
    static void Main()
    {
        string outputPath = "merged.pdf";
        string[] inputFiles = { "document1.pdf", "document2.pdf", "document3.pdf" };

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdfDoc = new PdfDocument(writer))
        {
            PdfMerger merger = new PdfMerger(pdfDoc);

            foreach (string file in inputFiles)
            {
                using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
                {
                    merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
                }
            }
        }
    }
}

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Kernel.Utils;
using System.IO;

class Program
{
    static void Main()
    {
        string outputPath = "merged.pdf";
        string[] inputFiles = { "document1.pdf", "document2.pdf", "document3.pdf" };

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdfDoc = new PdfDocument(writer))
        {
            PdfMerger merger = new PdfMerger(pdfDoc);

            foreach (string file in inputFiles)
            {
                using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
                {
                    merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
                }
            }
        }
    }
}

Imports iText.Kernel.Pdf
Imports iText.Kernel.Utils
Imports System.IO

Class Program
    Shared Sub Main()
        Dim outputPath As String = "merged.pdf"
        Dim inputFiles As String() = {"document1.pdf", "document2.pdf", "document3.pdf"}

        Using writer As New PdfWriter(outputPath)
            Using pdfDoc As New PdfDocument(writer)
                Dim merger As New PdfMerger(pdfDoc)

                For Each file As String In inputFiles
                    Using sourcePdf As New PdfDocument(New PdfReader(file))
                        merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages())
                    End Using
                Next
            End Using
        End Using
    End Sub
End Class

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfDocuments = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        };

        var merged = PdfDocument.Merge(pdfDocuments);
        merged.SaveAs("merged.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfDocuments = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        };

        var merged = PdfDocument.Merge(pdfDocuments);
        merged.SaveAs("merged.pdf");
    }
}

Imports IronPdf
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim pdfDocuments As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        }

        Dim merged = PdfDocument.Merge(pdfDocuments)
        merged.SaveAs("merged.pdf")
    End Sub
End Class

L'opération de fusion d'iText nécessite beaucoup de code boilerplate : création d'un PdfWriter pour la sortie, enveloppement dans un PdfDocument, création d'un PdfMerger, puis itération à travers les fichiers sources avec des déclarations using imbriquées pour chaque PdfDocument et PdfReader. Vous devez également spécifier les plages de pages avec merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages()).

IronPDF réduit cela à trois étapes : charger les documents avec PdfDocument.FromFile(), appeler la méthode statique PdfDocument.Merge() avec la liste, et sauvegarder. L'ensemble de l'opération de fusion devient lisible et facile à maintenir. En savoir plus sur la fusion et la division de PDF.

Exemple 3 : Créer un PDF avec du texte et des images

Avant (iText) :

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.IO.Image;

class Program
{
    static void Main()
    {
        string outputPath = "document.pdf";

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdf = new PdfDocument(writer))
        using (Document document = new Document(pdf))
        {
            document.Add(new Paragraph("Sample PDF Document"));
            document.Add(new Paragraph("This document contains text and an image."));

            Image img = new Image(ImageDataFactory.Create("image.jpg"));
            img.SetWidth(200);
            document.Add(img);
        }
    }
}

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.IO.Image;

class Program
{
    static void Main()
    {
        string outputPath = "document.pdf";

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdf = new PdfDocument(writer))
        using (Document document = new Document(pdf))
        {
            document.Add(new Paragraph("Sample PDF Document"));
            document.Add(new Paragraph("This document contains text and an image."));

            Image img = new Image(ImageDataFactory.Create("image.jpg"));
            img.SetWidth(200);
            document.Add(img);
        }
    }
}

Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports iText.IO.Image

Class Program
    Shared Sub Main()
        Dim outputPath As String = "document.pdf"

        Using writer As New PdfWriter(outputPath),
              pdf As New PdfDocument(writer),
              document As New Document(pdf)

            document.Add(New Paragraph("Sample PDF Document"))
            document.Add(New Paragraph("This document contains text and an image."))

            Dim img As New Image(ImageDataFactory.Create("image.jpg"))
            img.SetWidth(200)
            document.Add(img)
        End Using
    End Sub
End Class

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string html = @"
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string html = @"
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim html As String = "
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("document.pdf")
    End Sub
End Class

Cet exemple illustre parfaitement le changement de paradigme. iText nécessite :

• Déclarations using triplées imbriquées (PdfWriter, PdfDocument, Document)
• Création d'objets Paragraph pour chaque élément texte avec new Paragraph()
• Utilisation de ImageDataFactory.Create() pour charger des images
• Création d'un objet Image et appel à SetWidth() séparément
• Appel à document.Add() pour chaque élément

IronPDF utilise le HTML standard : <h1> pour les titres, <p> pour les paragraphes et <img> pour les images avec un attribut width. Les développeurs web peuvent immédiatement tirer parti de leurs compétences existantes et les concepteurs peuvent styliser les documents à l'aide des feuilles de style CSS qu'ils connaissent déjà.

Changement de paradigme : De la programmation à l'HTML d'abord

Le changement le plus important dans cette migration iText est d'ordre conceptuel. iText crée des PDF par programmation :

// iText approach
document.Add(new Paragraph("Title")
    .SetTextAlignment(TextAlignment.CENTER)
    .SetFontSize(24)
    .SetBold());

var table = new Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth();
table.AddHeaderCell(new Cell().Add(new Paragraph("ID")));
table.AddHeaderCell(new Cell().Add(new Paragraph("Name")));
// ... many more lines

// iText approach
document.Add(new Paragraph("Title")
    .SetTextAlignment(TextAlignment.CENTER)
    .SetFontSize(24)
    .SetBold());

var table = new Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth();
table.AddHeaderCell(new Cell().Add(new Paragraph("ID")));
table.AddHeaderCell(new Cell().Add(new Paragraph("Name")));
// ... many more lines

' iText approach
document.Add(New Paragraph("Title") _
    .SetTextAlignment(TextAlignment.CENTER) _
    .SetFontSize(24) _
    .SetBold())

Dim table = New Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth()
table.AddHeaderCell(New Cell().Add(New Paragraph("ID")))
table.AddHeaderCell(New Cell().Add(New Paragraph("Name")))
' ... many more lines

IronPDF utilise HTML et CSS :

//IronPDF approach
string html = @"
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>";

var pdf = renderer.RenderHtmlAsPdf(html);

//IronPDF approach
string html = @"
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>";

var pdf = renderer.RenderHtmlAsPdf(html);

Imports IronPdf

Dim html As String = "
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>"

Dim pdf = renderer.RenderHtmlAsPdf(html)

AGPL Exposition enlevée

En vertu des termes AGPL d'iText, une application web utilisant iText est généralement censée publier son code source à toute personne interagissant avec elle via un réseau ; la licence commerciale est l'alternative. La licence commerciale d'IronPDF permet un déploiement dans des logiciels propriétaires sans exigence de licence virale.

Aucun complément pdfHTML requis

iText nécessite l'extension itext.pdfhtml séparée (actuellement 6.3.2) pour la conversion HTML-en-PDF, vendue en plus du paquetage principal itext.IronPDF inclut le rendu HTML basé sur Chromium dans le package de base.

Method Replacement Patterns (Modèles de remplacement de méthodes)

Édition 1 : PdfWriter/Document Pattern (en anglais)

Problème : Le code utilise le modèle de nesting PdfWriter → PdfDocument → Document.

Solution: Replace with ChromePdfRenderer:

// Delete this iText pattern:
// using (var writer = new PdfWriter(outputPath))
// using (var pdfDoc = new PdfDocument(writer))
// using (var document = new Document(pdfDoc))

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

// Delete this iText pattern:
// using (var writer = new PdfWriter(outputPath))
// using (var pdfDoc = new PdfDocument(writer))
// using (var document = new Document(pdfDoc))

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

Imports IronPdf

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(outputPath)

Édition 2 : HtmlConverter introuvable

Problème : Le code utilise iText.Html2pdf.HtmlConverter, qui se trouve dans l'extension itext.pdfhtml achetée séparément.

Solution : Utilisez le rendu HTML intégré d'IronPDF :

// iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream);

//IronPDF(built-in)
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

// iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream);

//IronPDF(built-in)
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

' iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream)

' IronPDF(built-in)
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(outputPath)

Édition 3 : Complexité de PdfMerger

Problème : L'PdfMerger d'iText nécessite des lecteurs imbriqués et la spécification de plages de pages.

Solution : Utilisez la méthode de fusion statique d'IronPDF :

// iText merger pattern (delete this)
// using (PdfDocument pdfDoc = new PdfDocument(writer))
// {
//     PdfMerger merger = new PdfMerger(pdfDoc);
//     foreach (string file in inputFiles)
//     {
//         using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
//         {
//             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
//         }
//     }
// }

//IronPDF(simple)
var merged = PdfDocument.Merge(pdfDocuments);
merged.SaveAs("merged.pdf");

// iText merger pattern (delete this)
// using (PdfDocument pdfDoc = new PdfDocument(writer))
// {
//     PdfMerger merger = new PdfMerger(pdfDoc);
//     foreach (string file in inputFiles)
//     {
//         using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
//         {
//             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
//         }
//     }
// }

//IronPDF(simple)
var merged = PdfDocument.Merge(pdfDocuments);
merged.SaveAs("merged.pdf");

Imports System.Collections.Generic

' iText merger pattern (delete this)
' Using pdfDoc As New PdfDocument(writer)
'     Dim merger As New PdfMerger(pdfDoc)
'     For Each file As String In inputFiles
'         Using sourcePdf As New PdfDocument(New PdfReader(file))
'             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages())
'         End Using
'     Next
' End Using

' IronPDF(simple)
Dim merged = PdfDocument.Merge(pdfDocuments)
merged.SaveAs("merged.pdf")

Pré-migration

• Inventorier tous les appels à l'API iText dans le code source
• Identifier les modèles de construction de PDF programmatiques (Paragraphe, Tableau, Cellule)
• Utilisation de Document HtmlConverter (module complémentaire pdfHTML)
• Évaluer le risque de conformité à l'AGPL
• Obtenir une clé de licence IronPDF

Migration de code

• Supprimer les paquets iText NuGet : dotnet remove package itext (et l'alias obsolète itext7, plus itext.pdfhtml / iTextSharp si présent)
• Installer le paquet IronPDF NuGet : dotnet add package IronPdf
• Mettre à jour les importations de namespaces (using iText.* → using IronPdf)
• Remplacer le modèle Document avec ChromePdfRenderer
• Convertir Cell en éléments HTML
• Remplacer HtmlConverter.ConvertToPdf() avec RenderHtmlAsPdf()
• Mettre à jour les opérations de fusion vers PdfDocument.Merge()
• Ajouter l'initialisation de la clé de licence au démarrage

Essai

• Tester tous les chemins de génération de PDF
• Vérifier que le rendu visuel correspond aux attentes
• Test avec du contenu HTML/CSS complexe
• Performances de référence

Après la migration

• Supprimer les fichiers de licence et les références iText
• Mise à jour de la documentation
• Annuler l'abonnement iText (le cas échéant)
• Archiver le code iText hérité