Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. migration de peachpdf vers IronPdf
GUIDES DE MIGRATION

Comment migrer de PeachPDF à IronPDF en C#

Curtis Chau
Curtis Chau
Publié:

Migrer de PeachPDFversIronPDFpermet d'accéder à une génération de PDF de niveau entreprise avec des fonctionnalités complètes, un développement actif et un support professionnel. Ce guide fournit un chemin de migration complet, étape par étape, qui transforme votre flux de travail HTML-PDF de base en une solution PDF complète avec un rendu Chromium moderne, des options de sécurité avancées et des capacités de manipulation étendues.

Pourquoi migrer de PeachPDFà IronPDF

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 PDF relativement nouvelle et peu connue qui n'a pas la maturité, les fonctionnalités et le support des solutions établies. Principales raisons de migrer :

  1. Fonctionnalités limitées : PeachPDFne dispose pas de fonctionnalités avancées telles que les signatures numériques, la conformité PDF/Aet l'extraction de texte sophistiquée.

  2. Petite communauté : documentation, exemples et soutien communautaire limités. Avec une base d'utilisateurs réduite, le soutien de la communauté peut être rare, ce qui rend difficile l'obtention d'une assistance ou la recherche d'une documentation complète.

  3. Un avenir incertain : Les nouvelles bibliothèques sans antécédents établis comportent un risque d'adoption.

  4. Prise en charge HTML de base : capacités de rendu CSS et JavaScriptlimitées.

  5. Aucun support aux entreprises : aucune option de support professionnel ni de SLA.

Comparaison PeachPDFvs IronPDF

Fonctionnalité/Caractéristique PeachPDF IronPDF
Mise en œuvre Pure .NET Géré avec une large compatibilité
Licence Open Source (BSD-3-Clause) Commercial
Base d'utilisateurs Petit Important (plus de 40 millions de téléchargements)
Support Orienté vers la communauté Professionnel avec un support dédié
Rendu HTML Basique Chromium complet
Support CSS Limité CSS3 complet
JavaScript Basique ES2024 complet
Signatures numériques Non Oui
Conformité PDF/A Non Oui
Documentation Limité Une traduction
Statut de développement En développement Version mature et stable

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 d'assistance professionnelle est un avantage certain, offrant des résolutions rapides aux problèmes rencontrés par les développeurs.

Pour les équipes qui prévoient l'adoption de .NET 10 et C# 14 jusqu'en 2025 et 2026,IronPDFoffre des fonctionnalités complètes et une maintenance active qui garantissent une stabilité et une compatibilité à long terme avec les frameworks .NET modernes.

Avant de commencer

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.com

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
SHELL

Configuration de la licence

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

Identifier l'utilisation de PeachPDF

# Audit PeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "HtmlToPdfConverter\|Convert\|ConvertUrl" --include="*.cs" .
# Audit PeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "HtmlToPdfConverter\|Convert\|ConvertUrl" --include="*.cs" .
SHELL

Référence API complète

Modifications de l'espace de nommage

// Before: PeachPDF
using PeachPDF;
using System.IO;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
// Before: PeachPDF
using PeachPDF;
using System.IO;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
$vbLabelText   $csharpLabel

Mappages de l'API de base

PeachPDF IronPDF Notes
new HtmlToPdfConverter() new ChromePdfRenderer() Créer un moteur de rendu
converter.Convert(html) renderer.RenderHtmlAsPdf(html) HTML vers PDF
converter.ConvertUrl(url) renderer.RenderUrlAsPdf(url) URL vers PDF
converter.Header renderer.RenderingOptions.HtmlHeader Contenu de l'en-tête
converter.Footer renderer.RenderingOptions.HtmlFooter Contenu du pied de page
File.WriteAllBytes(path, pdf) pdf.SaveAs(path) Enregistrer le fichier
pdf (byte[]) pdf.BinaryData Obtenir des octets
PdfReader.LoadFromFile(path) PdfDocument.FromFile(path) Charger le PDF
document.MergeWith(other) PdfDocument.Merge(pdfs) Fusionner des PDF

Exemples de migration de code

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

Avant (PeachPDF):

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
$vbLabelText   $csharpLabel

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

Cet exemple illustre la différence fondamentale entre les deux bibliothèques. PeachPDFutilise HtmlToPdfConverter avec une méthode Convert() qui renvoie un byte[], nécessitant File.WriteAllBytes()pour l'enregistrement.IronPDFutilise ChromePdfRenderer avec RenderHtmlAsPdf() qui renvoie un objet PdfDocument avec une méthode intégrée SaveAs().

Les principaux avantages de l'approche d'IronPDF : l'objet PdfDocument peut être manipulé davantage (ajout de filigranes, fusion, paramètres de sécurité) avant l'enregistrement, alors que le tableau d'octets de PeachPDFest une sortie finale. L'approche d'IronPDF offre une syntaxe plus propre et une meilleure intégration avec les applications .NET modernes. Consultez la documentation HTML vers PDF pour des exemples complets.

Exemple 2 : Conversion d'une URL en PDF

Avant (PeachPDF):

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        var pdf = converter.ConvertUrl(url);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        var pdf = converter.ConvertUrl(url);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
$vbLabelText   $csharpLabel

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

PeachPDF utilise ConvertUrl() tandis qu'IronPDF utilise RenderUrlAsPdf(). Le nommage des méthodes dansIronPDFest plus descriptif : il indique explicitement qu'une URL est rendue sous forme de PDF. Les deux bibliothèques gèrent la conversion d'URL en PDF de manière similaire, mais le moteur Chromium complet d'IronPDF offre un rendu supérieur des pages web modernes avec CSS et JavaScriptcomplexes. Pour en savoir plus, consultez nos tutoriels.

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

Avant (PeachPDF):

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        converter.Header = "<div style='text-align:center'>My Header</div>";
        converter.Footer = "<div style='text-align:center'>Page {page}</div>";
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("document.pdf", pdf);
    }
}
using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        converter.Header = "<div style='text-align:center'>My Header</div>";
        converter.Footer = "<div style='text-align:center'>Page {page}</div>";
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("document.pdf", pdf);
    }
}
$vbLabelText   $csharpLabel

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

Cet exemple illustre une différence architecturale essentielle. PeachPDFutilise des propriétés de chaînes simples (converter.Header et converter.Footer) pour les en-têtes et les pieds de page.IronPDFutilise des objets HtmlHeaderFooter affectés aux RenderingOptions.HtmlHeader et RenderingOptions.HtmlFooter.

L'approcheIronPDFoffre plus de flexibilité - les objets HtmlHeaderFooter peuvent inclure des propriétés supplémentaires comme MaxHeight pour contrôler la taille de l'en-tête/du pied de page. Notez que les deux bibliothèques utilisent {page} comme espace réservé au numéro de page.IronPDFprend également en charge {total-pages} pour le nombre total de pages.

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

Notesde migration essentielles

Changement de classe de convertisseur

PeachPDF utilise HtmlToPdfConverter ;IronPDFutilise ChromePdfRenderer :

// PeachPDF
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
// PeachPDF
var converter = new HtmlToPdfConverter();

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

Changement de type de retour

PeachPDF retourne byte[] ;IronPDFrenvoie PdfDocument :

// PeachPDF: Returns byte array
byte[] pdf = converter.Convert(html);
File.WriteAllBytes("output.pdf", pdf);

// IronPDF: Returns PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;
// PeachPDF: Returns byte array
byte[] pdf = converter.Convert(html);
File.WriteAllBytes("output.pdf", pdf);

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

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

// PeachPDF: Simple string properties
converter.Header = "<div>Header</div>";
converter.Footer = "<div>Footer</div>";

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

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

Modification des noms de méthode

PeachPDF IronPDF
Convertir(html) RenderHtmlAsPdf(html)
ConvertUrl(url) RenderUrlAsPdf(url)
File.WriteAllBytes() SaveAs()

Nouvelles capacités après la migration

Après avoir migré vers IronPDF, vous bénéficiez de fonctionnalités que PeachPDFne peut pas vous offrir :

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

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

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

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

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

Résumé de la comparaison des fonctionnalités

Fonction PeachPDF IronPDF
HTML vers PDF Basique Chromium complet
URL vers PDF Limité Oui
Grille CSS/Flexbox Non Oui
JavaScript Limité ES2024 complet
Fusionner des PDF Oui Oui
Diviser les PDF Limité Oui
Filigranes Limité HTML complet
En-têtes/Pieds de page Basique HTML complet
Signatures numériques Non Oui
PDF/A Non Oui
Remplissage de formulaires Limité Oui
Extraction de texte Basique Oui
Extraction d'images Non Oui
Prise en charge de l'asynchronisme Limité Oui
Multiplateforme Inconnu Oui

Problèmes de migration courants

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

Problème: PeachPDFutilise un modèle de convertisseur avec sortie de tableau d'octets ;IronPDFutilise un modèle de rendu avec sortie PdfDocument.

Solution:

// PeachPDFpattern
var converter = new HtmlToPdfConverter();
var pdf = converter.Convert(html);
File.WriteAllBytes(path, pdf);

//IronPDFpattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);
// PeachPDFpattern
var converter = new HtmlToPdfConverter();
var pdf = converter.Convert(html);
File.WriteAllBytes(path, pdf);

//IronPDFpattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);
$vbLabelText   $csharpLabel

Enjeu 2 : Différence de méthode de sauvegarde

Problème: PeachPDFnécessite File.WriteAllBytes();IronPDFdispose d'un SaveAs()intégré.

Solution: Remplacez File.WriteAllBytes("path", pdf) par pdf.SaveAs("path").

Sujet 3 : Objets d'en-tête et de pied de page

Problème: PeachPDFutilise des propriétés de chaînes de caractères ;IronPDFutilise des propriétés d'objet.

Solution:Enveloppez les chaînes HTML dans les objets HtmlHeaderFooter avec la propriété HtmlFragment.

Liste de contrôle de la migration

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 licenceIronPDFsur ironpdf.com
  • Commencez par tester avec une licence d'essai IronPDF.

Modifications du paquet

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

Modifications du code

  • Mise à jour des importations d'espace de noms ( using PeachPDF; → using IronPdf; )
  • Ajoutez using IronPdf.Rendering; pour les fonctionnalités d'en-tête/pied de page
  • Remplacez HtmlToPdfConverter par ChromePdfRenderer
  • Remplacez converter.Convert(html)par renderer.RenderHtmlAsPdf(html)
  • Remplacez converter.ConvertUrl(url)par renderer.RenderUrlAsPdf(url)
  • Remplacez File.WriteAllBytes(path, pdf)par pdf.SaveAs(path)
  • Remplacez converter.Header/ Footer par les objets RenderingOptions.HtmlHeader / 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
Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit