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

Comment migrer de ZetPDF à IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

ZetPDF (zetpdf.com) est un SDK PDF .NET commercialement licencié dont la surface de l'API ressemble étroitement à PDFsharp — au point que la communauté PDFsharp a remis en question s'il s'agit d'un fork fermé. Le fournisseur le commercialise comme un moteur de code géré à 100 %, propriétaire. ZetPDFn'est pas distribué via NuGet — l'installation est un téléchargement ZIP depuis https://zetpdf.com/download/ — et le projet ne montre aucune activité de publication publique depuis 2021. Les prix sont perpétuels : $299 Projet Unique / $449 Multi / $599 OEM.

Ce guide fournit un chemin de migration de ZetPDFà IronPDF, avec des instructions pas à pas, des comparaisons de code et des exemples pour les développeurs .NET évaluant cette transition.

Pourquoi migrer de ZetPDF

L'API de dessin en coordonnées de ZetPDF, façonnée par PDFsharp, comporte des contraintes architecturales qui limitent les flux de travail modernes de génération de documents. Raisons courantes pour lesquelles les équipes envisagent une migration :

API Basée sur les Coordonnées : ZetPDFpositionne chaque élément via des coordonnées XGraphics précises. Le positionnement manuel crée une surcharge de maintenance à mesure que les exigences évoluent.

Pas de support CSS : Aucun système de style — les polices et les couleurs sont gérées par élément dans le code.

Rendu JavaScript impossible : Impossible de rendre le contenu Web dynamique ou d'exécuter du JavaScript lors de la génération du PDF.

Pas de conversion HTML en PDF native : La liste des fonctionnalités documentées de ZetPDFn'inclut pas de convertisseur HTML en PDF ou URL en PDF ; le rendu est uniquement un dessin XGraphics de bas niveau.

Pas de NuGet, versions en sommeil : La distribution est un ZIP du fournisseur depuis https://zetpdf.com/download/, sans activité de publication publique depuis 2021.

Sauts de page manuels : Le dépassement de page doit être calculé et géré manuellement au lieu d'une pagination automatique.

Mesure de texte requise : Le calcul manuel pour le retour à la ligne ajoute une surcharge de développement.

Le problème fondamental

ZetPDF et PDFsharp vous obligent à positionner chaque élément avec des coordonnées exactes :

// ZetPDF: Manuel positioning nightmare
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form
// ZetPDF: Manuel positioning nightmare
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form
' ZetPDF: Manuel positioning nightmare
graphics.DrawString("Name:", font, brush, New XPoint(50, 100))
graphics.DrawString("John Doe", font, brush, New XPoint(100, 100))
graphics.DrawString("Address:", font, brush, New XPoint(50, 120))
graphics.DrawString("123 Main St", font, brush, New XPoint(100, 120))
' ... hundreds of lines for a simple form
$vbLabelText   $csharpLabel

IronPDF utilise HTML/CSS- le moteur de mise en page s'occupe de tout :

// IronPDF: Simple HTML
var html = @"
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
// IronPDF: Simple HTML
var html = @"
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
' IronPDF: Simple HTML
Dim html As String = "
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

IronPDF vs ZetPDF: Comparaison des fonctionnalités

La compréhension des différences architecturales aide les décideurs techniques à évaluer l'investissement dans la migration :

Fonction ZetPDF IronPDF
Style API dessin XGraphics en forme de PDFsharp Rendu HTML de haut niveau
Conversion HTML vers PDF Pas dans la liste de fonctionnalités documentées Oui (Chromium complet)
Licence commerciale Oui, perpétuel ($299 / $449 / $599) Oui
Distribution Téléchargement ZIP (pas de package NuGet) NuGet (IronPdf)
Dernière activé publique Aucune version listée depuis 2021 Actif, sorties fréquentes
Support CSS Non CSS3 complet
JavaScript Non ES2024 complet
Mise en page automatique Non Oui
Sauts de page automatiques Non Oui
Tables Dessin manuel HTML
En-têtes/Pieds de page Manuel HTML/CSS
Marqueurs d'eau Code manuel Intégré
Fusionner des PDF Pas de premier assistant Oui
Diviser les PDF Pas de premier assistant Oui
Signatures numériques Non Oui
PDF/A Non Oui

Démarrage rapide : Migration de ZetPDFvers IronPDF

La migration peut commencer immédiatement grâce à ces étapes fondamentales.

Étape 1 : Remplacez la référence ZetPDFpar le package NuGet IronPDF

ZetPDF n'est pas sur NuGet — il est distribué sous forme de fichier ZIP depuis https://zetpdf.com/download/et est référencé en ajoutant ZetPDF.dll à votre projet. Après la migration, retirez cette référence DLL et installez IronPDF depuis NuGet :

# Remove the ZetPDF.dll reference from your csproj manually, then:
dotnet add package IronPdf
# Remove the ZetPDF.dll reference from your csproj manually, then:
dotnet add package IronPdf
SHELL

Étape 2 : Mise à jour des espaces de noms

Remplacez les espaces de noms ZetPDFpar l'espace de noms IronPDF:

// Before (ZetPDF)
using ZetPDF;
using ZetPDF.Drawing;
using ZetPDF.Fonts;

// After (IronPDF)
using IronPdf;
// Before (ZetPDF)
using ZetPDF;
using ZetPDF.Drawing;
using ZetPDF.Fonts;

// After (IronPDF)
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Étape 3 : initialisation de la licence

Ajouter l'initialisation de la licence au démarrage de l'application :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Exemples de migration de code

Conversion de HTML en PDF

La liste des fonctionnalités publiées de ZetPDFn'inclut pas de convertisseur HTML en PDF ou URL en PDF natif — sa surface documentée couvre la vue/impression PDF, les annotations, le chiffrement AES256, les champs de formulaire et l'extraction de texte. Le pseudo-wrapper ci-dessous illustre comment les équipes contournent généralement un point d'entrée HTML en PDF sur ZetPDF; en pratique, le travail revient à un rendu HTML externe ou à un dessin XGraphics de bas niveau.

Démarche ZetPDF(illustratif — pas de HTML en PDF natif) :

// ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // Non native HtmlToPdfConverter exists in ZetPDF— illustrative call only.
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // Non native HtmlToPdfConverter exists in ZetPDF— illustrative call only.
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        ' Non native HtmlToPdfConverter exists in ZetPDF— illustrative call only.
        Dim converter As New HtmlToPdfConverter()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class
$vbLabelText   $csharpLabel

Approche IronPDF:

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
Imports IronPdf
Imports System

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF fournit ChromePdfRenderer avec RenderHtmlAsPdf(), ce qui retourne un objet PdfDocument — vous pouvez sauvegarder dans un fichier, récupérer des données binaires ou effectuer des opérations supplémentaires avant de sauvegarder.

Pour les scénarios avancés de conversion de HTML en PDF, voir le guide de conversion de HTML en PDF.

Conversion des URL en PDF

ZetPDF n'a également pas de convertisseur URL en PDF natif ; le rendu HTML/URL ne fait pas partie de la liste de fonctionnalités documentées. Les chemins de migration pratiques jumellent généralement ZetPDFavec un moteur de rendu HTML externe ou passent à une bibliothèque basée sur Chromium comme IronPDF.

Démarche ZetPDF(illustratif — pas de URL en PDF natif) :

// ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // Non native ConvertUrlToPdf exists in ZetPDF— illustrative call only.
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
// ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // Non native ConvertUrlToPdf exists in ZetPDF— illustrative call only.
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        ' Non native ConvertUrlToPdf exists in ZetPDF— illustrative call only.
        Dim converter As New HtmlToPdfConverter()
        Dim url As String = "https://www.example.com"
        converter.ConvertUrlToPdf(url, "webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class
$vbLabelText   $csharpLabel

Approche IronPDF:

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
Imports IronPdf
Imports System

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()
        Dim url As String = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

L'RenderUrlAsPdf() d'IronPDF sur ChromePdfRenderer exploite un moteur de rendu Chromium complet pour capturer des pages web incluant l'exécution JavaScript et le CSS moderne.

Explorez la URL vers la documentation PDF pour l'authentification et les options d'en-tête personnalisées.

Fusionner plusieurs fichiers PDF

ZetPDF ne fournit pas un assistant PdfMerger.MergeFiles() en une seule ligne. La fusion suit le même schéma que PDFsharp (auquel ZetPDFressemble) : ouvrez chaque entrée avec PdfReader, puis bouclez les pages dans une sortie PdfDocument et Save(). Le wrapper illustratif ci-dessous reflète la surface de IronPDF pour comparaison ; dans le code ZetPDFréel, vous écrivez la boucle manuelle.

Démarche ZetPDF(illustratif — pas de fusionneur PDF intégré) :

// ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // ZetPDFhas no built-in PdfMerger — illustrative call only.
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
// ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // ZetPDFhas no built-in PdfMerger — illustrative call only.
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
Imports ZetPDF
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        ' ZetPDFhas no built-in PdfMerger — illustrative call only.
        Dim merger As New PdfMerger()
        Dim files As New List(Of String) From {"document1.pdf", "document2.pdf"}
        merger.MergeFiles(files, "merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

Approche IronPDF:

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim pdfs As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        }
        Dim merged As PdfDocument = PdfDocument.Merge(pdfs)
        merged.SaveAs("merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF charge les documents comme objets PdfDocument en utilisant PdfDocument.FromFile(), puis les fusionne avec la méthode statique PdfDocument.Merge(). L'approche orientée objet permet des opérations supplémentaires sur le document fusionné avant l'enregistrement.

Explorez la documentation sur la fusion de fichiers PDF pour obtenir des options de fusion supplémentaires.

Dessin basé sur les coordonnées vs HTML

Pour les développeurs disposant d'un code ZetPDFexistant utilisant des graphiques basés sur les coordonnées, le chemin de migration consiste à convertir les commandes de dessin en HTML/CSS.

Approche basée sur les coordonnées ZetPDF:

using ZetPDF;
using ZetPDF.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Width = XUnit.FromMillimeter(210);
page.Height = XUnit.FromMillimeter(297);

var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");
using ZetPDF;
using ZetPDF.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Width = XUnit.FromMillimeter(210);
page.Height = XUnit.FromMillimeter(297);

var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");
Imports ZetPDF
Imports ZetPDF.Drawing

Dim document As New PdfDocument()
Dim page = document.AddPage()
page.Width = XUnit.FromMillimeter(210)
page.Height = XUnit.FromMillimeter(297)

Dim graphics = XGraphics.FromPdfPage(page)
Dim titleFont As New XFont("Arial", 24, XFontStyle.Bold)
Dim bodyFont As New XFont("Arial", 12)

graphics.DrawString("Company Report", titleFont, XBrushes.Navy, New XPoint(50, 50))
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black, New XPoint(50, 80))
graphics.DrawString("Generated: " & DateTime.Now.ToString(), bodyFont, XBrushes.Gray, New XPoint(50, 100))

document.Save("report.pdf")
$vbLabelText   $csharpLabel

Approche IronPDF HTML:

using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 50px;}}
        h1 {{color: navy;}}
        .date {{color: gray;}}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 50px;}}
        h1 {{color: navy;}}
        .date {{color: gray;}}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
Imports IronPdf

Dim html As String = $"
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 50px;}}
        h1 {{color: navy;}}
        .date {{color: gray;}}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

L'approche ZetPDFnécessite la création d'objets de police, le calcul des positions exactes des pixels et la gestion manuelle du contexte graphique. L'approche d'IronPDF utilise le HTML et le CSS standard que les développeurs web connaissent déjà - les polices, les couleurs et la mise en page sont gérées par des propriétés CSS familières.

Référence de mappage de l'API ZetPDFvers IronPDF

Cette cartographie accélère la migration en indiquant les équivalents directs des API :

ZetPDF IronPDF
new PdfDocument() new ChromePdfRenderer()
document.AddPage() Automatique
XGraphics.FromPdfPage(page) N/A (HTML/CSS à la place)
graphics.DrawString() Éléments de texte HTML
graphics.DrawImage() balise
graphics.DrawLine() bordures CSS /
graphics.DrawRectangle() CSS border + div
new XFont() CSS font-family
XBrushes.Black CSS color
document.Save() pdf.SaveAs()
PdfReader.Open() PdfDocument.FromFile()
(no native HTML-to-PDF) ChromePdfRenderer.RenderHtmlAsPdf()
(no native URL-to-PDF) ChromePdfRenderer.RenderUrlAsPdf()
(manual page-copy loop) PdfDocument.Merge()

Problèmes de migration courants et solutions

Édition 1 : Mise en page basée sur les coordonnées

ZetPDF: Tout nécessite des coordonnées X,Y exactes avec un positionnement manuel.

Solution: Utiliser la mise en page HTML/CSS. Pour un positionnement absolu lorsque cela est nécessaire, utilisez CSS :

.positioned-element {
    position: absolute;
    top: 100px;
    left: 50px;
}

Édition 2 : Gestion des objets de police

ZetPDF : Créez des objets XFont pour chaque variation de police.

Solution: Utilisez CSS fontamily - les polices sont gérées automatiquement :

<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; font-weight: bold; }
</style>
<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; font-weight: bold; }
</style>
HTML

Numéro 3 : Traitement des couleurs

ZetPDF : Utilisez des objets XBrushes et des couleurs.

Solution: Utilisez les couleurs CSS standard :

.header { color: navy; background-color: #f5f5f5; }
.warning { color: rgb(255, 0, 0); }

Edition 4 : Sauts de page manuels

ZetPDF: Suivi de la position Y et création manuelle de nouvelles pages en cas de débordement du contenu.

Solution:IronPDF gère les sauts de page automatiques. Pour un contrôle explicite, utilisez CSS :

.section { page-break-after: always; }
.keep-together { page-break-inside: avoid; }

Edition 5 : Création de tableaux

ZetPDF: Il faut dessiner manuellement des rectangles, des lignes et positionner du texte.

Solution: Utilisez des tableaux HTML standard avec un style CSS :

<table style="border-collapse: collapse; width: 100%;">
    <tr>
        <th style="border: 1px solid black; padding: 8px;">Header</th>
    </tr>
    <tr>
        <td style="border: 1px solid black; padding: 8px;">Data</td>
    </tr>
</table>
<table style="border-collapse: collapse; width: 100%;">
    <tr>
        <th style="border: 1px solid black; padding: 8px;">Header</th>
    </tr>
    <tr>
        <td style="border: 1px solid black; padding: 8px;">Data</td>
    </tr>
</table>
HTML

Liste de contrôle pour la migration vers ZetPDF

Tâches préalables à la migration

Auditez votre base de code pour identifier toute utilisation de ZetPDF:

grep -r "using ZetPDF" --include="*.cs" .
grep -r "XGraphics\|XFont\|XBrushes\|PdfReader" --include="*.cs" .
grep -r "using ZetPDF" --include="*.cs" .
grep -r "XGraphics\|XFont\|XBrushes\|PdfReader" --include="*.cs" .
SHELL

Documenter le code de dessin basé sur les coordonnées qui doit être converti en HTML. Notez les modèles d'utilisation des polices et des couleurs. Mettez en correspondance les structures de mise en page avec les équivalents HTML.

Tâches de mise à jour du code

  1. Supprimez la référence ZetPDF.dll manuelle de votre .csproj
  2. Installez le package NuGet IronPDF(dotnet add package IronPdf)
  3. Mettez à jour les imports de namespace de ZetPDF à IronPdf
  4. Remplacez tous les wrappers HTML-vers-PDF autour de ZetPDFpar ChromePdfRenderer.RenderHtmlAsPdf()
  5. Remplacez tous les wrappers URL-vers-PDF par ChromePdfRenderer.RenderUrlAsPdf()
  6. Remplacez les boucles de fusion manuelle par PdfDocument.Merge()
  7. Convertissez les appels DrawString() vers des éléments de texte HTML
  8. Convertissez XFont en CSS font-family
  9. Remplacez XBrushes par des couleurs CSS
  10. Ajoutez l'initialisation de la licence IronPDF au démarrage (IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";)

Test de post-migration

Après la migration, vérifiez ces aspects :

  • Comparer les résultats visuels pour s'assurer que l'apparence correspond ou s'améliore
  • Vérifier que les polices s'affichent comme prévu avec le style CSS
  • Test des sauts de page avec la pagination automatique
  • Vérifier que les images sont positionnées et affichées correctement
  • Tester les opérations de fusion de PDF pour obtenir des résultats corrects
  • Confirmer que toutes les fonctionnalités existantes fonctionnent avec la nouvelle implémentation

Avantages clés de la migration vers IronPDF

Le passage de ZetPDFà IronPDF présente plusieurs avantages décisifs :

Moteur de rendu Chromium moderne :IronPDF utilise Chromium pour la conversion HTML vers PDF, assurant une prise en charge complète de CSS3 et de JavaScript ES2024. Les cadres modernes et les conceptions réactives ont un rendu correct.

Création de contenu basé sur HTML : les développeurs web peuvent tirer parti de leurs compétences existantes en HTML et CSS. Il n'est pas nécessaire d'apprendre les API de dessin basées sur les coordonnées ou de gérer les objets de police.

Mise en page et pagination automatiques : le retour à la ligne, les sauts de page et la mise en page fluide sont automatiques. Pas de calcul manuel de la position des éléments.

API simplifiée : appels de méthode unique pour les opérations courantes. PdfDocument.Merge() remplace les modèles complexes de gestion de chemins de fichiers.

Développement actif : Le rythme de sortie régulier de IronPDF maintient la bibliothèque à jour avec les versions modernes de .NET, contrairement à l'absence d'activité de publication publique de ZetPDFdepuis 2021.

Ensemble de fonctionnalités complet : Filigrane intégré, signatures numériques, conformité PDF/A et fonctionnalités avancées de manipulation de PDF absentes de la surface documentée de ZetPDF.

Veuillez noterPDFSharp et ZetPDFsont des marques déposées de leurs propriétaires respectifs. Ce site n'est pas affilié à, approuvé par ou parrainé par ZetPDFou empira Software GmbH. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.

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

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi