Comment expurger du texte et des régions dans un PDF à l'aide de C#

Comprendre PeachPDF

PeachPDF est un outil relativement nouveau dans l'écosystème .NET, conçu pour les développeurs qui ont besoin de convertir du HTML en PDF. En tant que bibliothèque, PeachPDFpromet une implémentation .NET pure, se distinguant par le fait qu'elle ne dépend pas de processus externes, ce qui garantit qu'elle peut être intégrée de manière transparente sur toutes les plateformes où .NET est pris en charge. Cette caractéristique positionne PeachPDFcomme un choix attrayant pour les projets à la recherche d'une solution de bibliothèque gérée et légère.

Malgré son potentiel, PeachPDFest encore en cours de développement, ce qui met en évidence à la fois des possibilités intéressantes et des limites notables. PeachPDFreste attrayant en raison de son noyau .NET pur, qui promet un déploiement simple dans divers environnements. Toutefois, cela se traduit également par une adoption limitée, avec une base d'utilisateurs plus restreinte et un soutien communautaire.

Les limites de PeachPDF

PeachPDF est une bibliothèque .NET pré-1.0 maintenue par une seule personne (dernière 0.7.26, octobre 2025) publiée sous licenceBSD-3-Clausepar jhaygood86. Il manque la maturité, les fonctionnalités et le support des solutions établies. Principales raisons de migrer :

1. Ensemble de fonctionnalités pré-1.0 : PeachPDFn'a pas de signatures numériques intégrées, conformité PDF/A, OCR, remplissage de formulaires, ou API d'en-tête/pied de page au niveau des pages.

2. Pas de moteur JavaScript: PeachPDFest un moteur de rendu de mise en page construit sur PeachPDF.PdfSharpCore, pas un navigateur ; les scripts et les mises en page Grid/Flexbox complexes ne s'exécutent pas.

3. net8.0 uniquement : le package cible net8.0 ; les projets .NET Framework / .NET 6 nécessitent une mise à niveau ou choisir une autre bibliothèque.

4. Petite communauté : un seul mainteneur GitHub, documentation limitée, exemples limités.

5. Pas de support Entreprise : pas de support commercial ou d'options SLA.

Comparaison PeachPDFvs IronPDF

IronPDF se distingue par des fonctionnalités plus larges, prenant en charge non seulement les conversions HTML vers PDF, mais aussi l'OCR, le filigrane et d'autres fonctions avancées. Sa structure de support professionnel offre des solutions rapides aux problèmes rencontrés par les développeurs.

Pour les équipes adoptant .NET moderne,IronPDF offre des fonctionnalités complètes et une maintenance active pour soutenir la stabilité à long terme à travers les versions actuelles de .NET.

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 PeachPDF
dotnet remove package PeachPDF

# Install IronPDF
dotnet add package IronPdf

# Remove PeachPDF
dotnet remove package PeachPDF

# Install IronPDF
dotnet add package IronPdf

Configuration de la licence

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Identifier l'utilisation de PeachPDF

# Audit PeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "PdfGenerator\|PdfGenerateConfig\|GeneratePdf" --include="*.cs" .

# Audit PeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "PdfGenerator\|PdfGenerateConfig\|GeneratePdf" --include="*.cs" .

Modifications de l'espace de nommage

// Before: PeachPDF
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before: PeachPDF
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO
Imports System.Threading.Tasks

Mappages de l'API de base

Exemple 1 : Conversion d'une chaîne HTML en fichier PDF

Avant (PeachPDF):

using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            PageOrientation = PageOrientation.Portrait
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("output.pdf");
        document.Save(stream);
    }
}

using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            PageOrientation = PageOrientation.Portrait
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("output.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.PdfSharpCore
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim config As New PdfGenerateConfig With {
            .PageSize = PageSize.Letter,
            .PageOrientation = PageOrientation.Portrait
        }

        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(html, config)

        Using stream As FileStream = File.Create("output.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

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;

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

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

Cet exemple montre la différence fondamentale entre les deux bibliothèques. PeachPDFsépare un PdfGenerator (moteur) d'un PdfGenerateConfig (paramètres), expose une méthode async GeneratePdf, et retourne un document dont la méthode Save écrit dans un Stream.IronPDF utilise ChromePdfRenderer avec RenderHtmlAsPdf(), ce qui retourne un objet PdfDocument avec une méthode intégrée SaveAs().

Un avantage pratique de l'approche d'IronPDF : l'objet PdfDocument peut être manipulé davantage (ajout de filigranes, fusion, paramètres de sécurité) avant de sauvegarder, et SaveAs prend un chemin de fichier directement sans FileStream intermédiaire. Voir la documentation HTML vers PDF pour d'autres exemples.

Exemple 2 : Conversion d'une URL en PDF

Avant (PeachPDF):

// PeachPDFhas no ConvertUrl-style helper; URL fetching is wired via
// HttpClientNetworkAdapter and passing null HTML so the engine fetches the page.
using PeachPDF;
using PeachPDF.Network;
using PeachPDF.PdfSharpCore;
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var http = new HttpClient();

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            NetworkAdapter = new HttpClientNetworkAdapter(http, new Uri("https://www.example.com"))
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(null, config);

        using var stream = File.Create("webpage.pdf");
        document.Save(stream);
    }
}

// PeachPDFhas no ConvertUrl-style helper; URL fetching is wired via
// HttpClientNetworkAdapter and passing null HTML so the engine fetches the page.
using PeachPDF;
using PeachPDF.Network;
using PeachPDF.PdfSharpCore;
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var http = new HttpClient();

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            NetworkAdapter = new HttpClientNetworkAdapter(http, new Uri("https://www.example.com"))
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(null, config);

        using var stream = File.Create("webpage.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.Network
Imports PeachPDF.PdfSharpCore
Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim http As New HttpClient()

        Dim config As New PdfGenerateConfig With {
            .PageSize = PageSize.Letter,
            .NetworkAdapter = New HttpClientNetworkAdapter(http, New Uri("https://www.example.com"))
        }

        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(Nothing, config)

        Using stream = File.Create("webpage.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim url = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

PeachPDF n'a pas de helper URL-vers-PDF de première classe ; vous définissez NetworkAdapter sur la config à un HttpClientNetworkAdapter et passez null HTML pour que le moteur récupère la page.IronPDF expose directement RenderUrlAsPdf(url). Parce que PeachPDFn'exécute pas JavaScript, les applications à une seule page et le contenu dynamique ne s'affichent généralement pas correctement via la route de l'adaptateur réseau ; Le moteur Chromium d'IronPDF gère le CSS et le JavaScriptmodernes. Pour en savoir plus, consultez nos tutoriels.

Exemple 3 : Ajout d'en-têtes et de pieds de page

Avant (PeachPDF):

// PeachPDFv0.7.x has no header/footer API. The closest approach is
// to embed the header/footer markup directly inside the source HTML
// using CSS positioning.
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = @"
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>";

        var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("document.pdf");
        document.Save(stream);
    }
}

// PeachPDFv0.7.x has no header/footer API. The closest approach is
// to embed the header/footer markup directly inside the source HTML
// using CSS positioning.
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = @"
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>";

        var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("document.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.PdfSharpCore
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>"

        Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(html, config)

        Using stream = File.Create("document.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>My Header</div>" };
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>Page {page}</div>" };
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>My Header</div>" };
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>Page {page}</div>" };
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {.HtmlFragment = "<div style='text-align:center'>My Header</div>"}
        renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {.HtmlFragment = "<div style='text-align:center'>Page {page}</div>"}
        Dim html As String = "<html><body><h1>Document Content</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("document.pdf")
    End Sub
End Module

Cet exemple illustre une différence architecturale essentielle. PeachPDFn'expose pas d'API pour les en-têtes/pieds de page sur PdfGenerator ou PdfGenerateConfig, donc la mise en forme de la page doit être dans le HTML source en utilisant le positionnement CSS.IronPDF utilise les objets HtmlHeaderFooter assignés à RenderingOptions.HtmlHeader et RenderingOptions.HtmlFooter, séparant la mise en forme de la page du contenu du document.

L'approche d'IronPDF expose également des propriétés comme MaxHeight pour contrôler la taille des en-têtes/pieds de page, et prend en charge les espaces réservés {page} et {total-pages} pour la numérotation des pages.

Notez l'espace de noms supplémentaire requis pour IronPDF: using IronPdf.Rendering; est nécessaire pour la classe HtmlHeaderFooter.

Changement de classe de générateur/rendu

PeachPDF utilise une paire PdfGenerator + PdfGenerateConfig ;IronPDF utilise un seul ChromePdfRenderer :

// PeachPDF
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();

// IronPDF
var renderer = new ChromePdfRenderer();

// PeachPDF
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();

// IronPDF
var renderer = new ChromePdfRenderer();

' PeachPDF
Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
Dim generator As New PdfGenerator()

' IronPDF
Dim renderer As New ChromePdfRenderer()

Async vs Sync, et Type de retour

La GeneratePdf de PeachPDFest uniquement asynchrone et retourne un document dont la méthode Save prend un Stream. La RenderHtmlAsPdf d'IronPDF est synchrone (une variante asynchrone RenderHtmlAsPdfAsync est également disponible) et retourne un PdfDocument :

// PeachPDF: async, save to a Stream
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create("output.pdf");
document.Save(fs);

// IronPDF: synchronous PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;

// PeachPDF: async, save to a Stream
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create("output.pdf");
document.Save(fs);

// IronPDF: synchronous PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;

Imports System.IO

' PeachPDF: async, save to a Stream
Dim document = Await generator.GeneratePdf(html, config)
Using fs As FileStream = File.Create("output.pdf")
    document.Save(fs)
End Using

' IronPDF: synchronous PdfDocument object
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
' Or get bytes: Dim bytes As Byte() = pdf.BinaryData

Modification de la propriété de l'en-tête/du pied de page

// PeachPDF: no header/footer API -- embed in source HTML
// (e.g. via CSS position:fixed)

// IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div>Header</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div>Footer</div>"
};

// PeachPDF: no header/footer API -- embed in source HTML
// (e.g. via CSS position:fixed)

// IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div>Header</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div>Footer</div>"
};

' PeachPDF: no header/footer API -- embed in source HTML
' (e.g. via CSS position:fixed)

' IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div>Header</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div>Footer</div>"
}

Modification des noms de méthode

Fusion de fichiers PDF

var pdf1 = PdfDocument.FromFile("doc1.pdf");
var pdf2 = PdfDocument.FromFile("doc2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

var pdf1 = PdfDocument.FromFile("doc1.pdf");
var pdf2 = PdfDocument.FromFile("doc2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

CONVERTER NOT RUNNING

Les filigranes avec HTML

var pdf = PdfDocument.FromFile("document.pdf");
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>");
pdf.SaveAs("watermarked.pdf");

var pdf = PdfDocument.FromFile("document.pdf");
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>");
pdf.SaveAs("watermarked.pdf");

Dim pdf = PdfDocument.FromFile("document.pdf")
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>")
pdf.SaveAs("watermarked.pdf")

Protection par mot de passe

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;

pdf.SaveAs("protected.pdf");

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;

pdf.SaveAs("protected.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>")

pdf.SecuritySettings.OwnerPassword = "owner123"
pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint

pdf.SaveAs("protected.pdf")

Signatures numériques

using IronPdf.Signing;

var pdf = PdfDocument.FromFile("document.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Document Approval",
    SigningLocation = "New York"
};
pdf.Sign(signature);
pdf.SaveAs("signed.pdf");

using IronPdf.Signing;

var pdf = PdfDocument.FromFile("document.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Document Approval",
    SigningLocation = "New York"
};
pdf.Sign(signature);
pdf.SaveAs("signed.pdf");

Imports IronPdf.Signing

Dim pdf = PdfDocument.FromFile("document.pdf")
Dim signature = New PdfSignature("certificate.pfx", "password") With {
    .SigningReason = "Document Approval",
    .SigningLocation = "New York"
}
pdf.Sign(signature)
pdf.SaveAs("signed.pdf")

Opérations asynchrones

var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>");
pdf.SaveAs("async_output.pdf");

var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>");
pdf.SaveAs("async_output.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>")
pdf.SaveAs("async_output.pdf")

Enjeu 1 : Modèle d'API différent

Problème : PeachPDFsépare PdfGenerator (moteur) de PdfGenerateConfig (paramètres) et est asynchrone ;IronPDF utilise un ChromePdfRenderer qui retourne un PdfDocument de manière synchrone.

Solution :

// PeachPDFpattern (async, stream-out)
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create(path);
document.Save(fs);

//IronPDF pattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);

// PeachPDFpattern (async, stream-out)
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create(path);
document.Save(fs);

//IronPDF pattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);

Imports System.IO

' PeachPDFpattern (async, stream-out)
Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
Dim generator As New PdfGenerator()
Dim document = Await generator.GeneratePdf(html, config)
Using fs As FileStream = File.Create(path)
    document.Save(fs)
End Using

' IronPDF pattern
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(path)

Problème 2 : Enregistrer cible un flux, pas un chemin

Problème : La document.Save(stream) de PeachPDFne prend qu'un Stream ; La pdf.SaveAs(path) d'IronPDF prend une chaîne de caractères pour le chemin.

Solution : Utilisez pdf.SaveAs("file.pdf") directement dans IronPDF au lieu d'ouvrir un FileStream.

Problème 3 : Pas d'opérations sur les PDF existants

Problème : PeachPDFest uniquement HTML-vers-PDF ; il ne peut pas charger, fusionner, diviser ou modifier des PDF existants.

Solution : Remplacez ces opérations par les PdfDocument.FromFile, PdfDocument.Merge, et pdf.AppendPdf d'IronPDF une fois migrées.

Pré-migration

• Auditer l'utilisation de PeachPDFdans le code source
• Documenter les configurations personnalisées
• Notez toutes les implémentations d'en-tête/pied de page
• Obtenez votre clé de licence IronPDF sur IronPDF
• Commencez par tester avec une licence d'essai IronPDF.

Modifications du paquet

• Supprimez le package NuGet PeachPDF
• Installez le package NuGet IronPdf : dotnet add package IronPdf

Modifications du code

• Mettez à jour les imports de l'espace de noms (using PeachPDF; → using IronPdf;)
• Ajoutez using IronPdf.Rendering; pour la fonctionnalité d'en-tête/pied de page
• Remplacez PdfGenerator + PdfGenerateConfig par ChromePdfRenderer
• Remplacez await generator.GeneratePdf(html, config) par renderer.RenderHtmlAsPdf(html) (ou RenderHtmlAsPdfAsync pour rester asynchrone)
• Remplacez HttpClientNetworkAdapter + GeneratePdf(null, config) par renderer.RenderUrlAsPdf(url)
• Remplacez document.Save(stream) par pdf.SaveAs(path)
• Remplacez les en-têtes/pieds de page intégrés au HTML par des objets HtmlFooter
• Ajouter l'initialisation de la licence au démarrage de l'application

Après la migration

• Tester la qualité du rendu HTML
• Vérifier que la sortie PDF correspond aux attentes
• Tester l'affichage de l'en-tête/du pied de page avec les numéros de page
• Ajouter de nouvelles fonctionnalités (sécurité, filigranes, fusion) selon les besoins