HiQPdf vs IronPDF : Guide de comparaison technique
HiQPdfvsIronPDF: Moteurs de rendu, conception de l'API et compatibilité moderne avec .NET
Lorsque les développeurs .NET évaluent les solutions HTML-to-PDF, HiQPdfapparaît comme une bibliothèque commerciale avec un rendu basé sur WebKit. HiQPdfprend en charge les formats HTML5/CSS3, mais son moteur WebKit, plus ancien, peut avoir des difficultés avec les frameworks JavaScript modernes, et la version gratuite impose une limite de 3 pages avec des filigranes intrusifs.IronPDFpropose une approche différente : un moteur de rendu moderne basé sur Chromium avec une prise en charge complète de JavaScript et un package unifié sur toutes les plateformes .NET.
Cette comparaison examine les deux bibliothèques à travers des dimensions techniquement pertinentes afin d'aider les développeurs professionnels et les architectes à prendre des décisions éclairées pour leurs besoins en .NET PDF.
Comprendre HiQPdf
HiQPdf est une bibliothèque commerciale de conversion de HTML en PDF qui utilise un moteur de rendu basé sur WebKit. La bibliothèque utilise HtmlToPdfcomme classe de conversion principale avec des méthodes telles que ConvertHtmlToMemory() et ConvertUrlToMemory() qui renvoient des données brutes byte[]. La configuration est gérée par des chaînes de propriétés sur l'objet Document, notamment Document.Header, Document.Footer et Document.PageSize.
La version gratuite de HiQPdfimpose une limite importante : un maximum de 3 pages pour les sorties PDF, suivi d'un filigrane intrusif. Il est donc difficile de procéder à des tests approfondis sur des documents plus volumineux lors de l'évaluation. La bibliothèque utilise plusieurs variantes de packages NuGet pour différentes plateformes (HiQPdf, HiQPdf.Free, HiQPdf.NetCore, HiQPdf.NetCore.x64, HiQPdf.Client), et la documentation ne clarifie pas explicitement la prise en charge de .NET Core ou .NET 5+.
Pour les en-têtes et les pieds de page, HiQPdfutilise des objets HtmlToPdfVariableElementajoutés aux collections Document.Header et Document.Footer. Les caractères de remplacement du numéro de page utilisent la syntaxe {CrtPage}pour la page en cours et {PageCount}pour le nombre total de pages.
Comprendre IronPDF
IronPDF est une bibliothèque PDF .NET qui utilise un moteur de rendu moderne Chromium, offrant une prise en charge complète de HTML5, CSS3 et des frameworks JavaScript, notamment React, Angular et Vue. La bibliothèque utilise ChromePdfRenderercomme classe de rendu principale avec des méthodes telles que RenderHtmlAsPdf() et RenderUrlAsPdf() qui renvoient des objets PdfDocument.
IronPDF fournit un seul package NuGet unifié pour toutes les plateformes avec une compatibilité documentée pour .NET 6, 7, 8, 9 et 10. La configuration utilise les propriétés Options de rendudirectement sur le moteur de rendu. Les en-têtes et les pieds de page peuvent utiliser TextHeaderFooter avec des propriétés telles que CenterText et FontSize. Les espaces réservés aux numéros de page utilisent la syntaxe {page}et {total-pages}.
Comparaison des moteurs de rendu et de la compatibilité
La différence fondamentale entre ces bibliothèques réside dans leurs moteurs de rendu et leur prise en charge des plateformes.
| Aspect | HiQPdf | IronPDF |
|---|---|---|
| Moteur de rendu | Basé sur WebKit (plus ancien) | Chrome moderne |
| <Niveau gratuit | limite de 3 pages + filigrane | essai complet de 30 jours |
| Support JS moderne | Limité | Complet (React, Angular, Vue) |
| Support .NET Core/5+ | Plusieurs paquets nécessaires | Paquet unique et unifié |
| Conception d'API | Chaînes de propriétés complexes | API propre et fluide |
| Support CSS3 | Partiel | Prise en charge complète |
| Documentation | Fragmenté | Complet |
| Paquet NuGet | Plusieurs variantes | Paquet unique |
Le moteur de HiQPdf, basé sur WebKit, est une technologie plus ancienne qui peut rencontrer des difficultés avec les frameworks JavaScript modernes et les structures HTML complexes. Le moteur Chromium d'IronPDF offre la même qualité de rendu que Google Chrome, garantissant une conversion précise des contenus web modernes.
Code Comparaison : Opérations PDF courantes
Conversion de HTML et d'URL en PDF
Les opérations les plus fondamentales démontrent les différences de conception des API.
HiQPdf :
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
HtmlToPdf htmlToPdfConverter = new HtmlToPdf();
byte[] pdfBuffer = htmlToPdfConverter.ConvertUrlToMemory("https://example.com");
System.IO.File.WriteAllBytes("output.pdf", pdfBuffer);
// Convert HTML string
string html = "<h1>Hello World</h1><p>This is a PDF document.</p>";
byte[] pdfFromHtml = htmlToPdfConverter.ConvertHtmlToMemory(html, "");
System.IO.File.WriteAllBytes("fromhtml.pdf", pdfFromHtml);
}
}
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
HtmlToPdf htmlToPdfConverter = new HtmlToPdf();
byte[] pdfBuffer = htmlToPdfConverter.ConvertUrlToMemory("https://example.com");
System.IO.File.WriteAllBytes("output.pdf", pdfBuffer);
// Convert HTML string
string html = "<h1>Hello World</h1><p>This is a PDF document.</p>";
byte[] pdfFromHtml = htmlToPdfConverter.ConvertHtmlToMemory(html, "");
System.IO.File.WriteAllBytes("fromhtml.pdf", pdfFromHtml);
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
IronPDF :
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("output.pdf");
// Convert HTML string
string html = "<h1>Hello World</h1><p>This is a PDF document.</p>";
var pdfFromHtml = renderer.RenderHtmlAsPdf(html);
pdfFromHtml.SaveAs("fromhtml.pdf");
}
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("output.pdf");
// Convert HTML string
string html = "<h1>Hello World</h1><p>This is a PDF document.</p>";
var pdfFromHtml = renderer.RenderHtmlAsPdf(html);
pdfFromHtml.SaveAs("fromhtml.pdf");
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
HiQPdf crée un convertisseur HtmlToPdf, appelle ConvertUrlToMemory() ou ConvertHtmlToMemory() pour obtenir des données brutes byte[], puis écrit manuellement sur le disque à l'aide de File.WriteAllBytes(). La méthode ConvertHtmlToMemory() requiert un deuxième paramètre pour l'URL de base (chaîne vide si elle n'est pas nécessaire).
IronPDF crée un ChromePdfRenderer, appelle RenderUrlAsPdf() ou RenderHtmlAsPdf() pour obtenir un objet PdfDocument, puis enregistre directement avec SaveAs(). L'API est plus concise grâce à la gestion de documents orientés objet.
Pour des options de rendu HTML avancées, explorez le guide de conversion du HTML en PDF.
Fusionner plusieurs fichiers PDF
La fusion de PDF illustre les différentes approches de la manipulation de documents.
HiQPdf :
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
// Create first PDF
HtmlToPdf converter1 = new HtmlToPdf();
byte[] pdf1 = converter1.ConvertHtmlToMemory("<h1>First Document</h1>", "");
System.IO.File.WriteAllBytes("doc1.pdf", pdf1);
// Create second PDF
HtmlToPdf converter2 = new HtmlToPdf();
byte[] pdf2 = converter2.ConvertHtmlToMemory("<h1>Second Document</h1>", "");
System.IO.File.WriteAllBytes("doc2.pdf", pdf2);
// Merge PDFs
PdfDocument document1 = PdfDocument.FromFile("doc1.pdf");
PdfDocument document2 = PdfDocument.FromFile("doc2.pdf");
document1.AddDocument(document2);
document1.WriteToFile("merged.pdf");
}
}
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
// Create first PDF
HtmlToPdf converter1 = new HtmlToPdf();
byte[] pdf1 = converter1.ConvertHtmlToMemory("<h1>First Document</h1>", "");
System.IO.File.WriteAllBytes("doc1.pdf", pdf1);
// Create second PDF
HtmlToPdf converter2 = new HtmlToPdf();
byte[] pdf2 = converter2.ConvertHtmlToMemory("<h1>Second Document</h1>", "");
System.IO.File.WriteAllBytes("doc2.pdf", pdf2);
// Merge PDFs
PdfDocument document1 = PdfDocument.FromFile("doc1.pdf");
PdfDocument document2 = PdfDocument.FromFile("doc2.pdf");
document1.AddDocument(document2);
document1.WriteToFile("merged.pdf");
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
IronPDF :
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
// Create first PDF
var pdf1 = renderer.RenderHtmlAsPdf("<h1>First Document</h1>");
pdf1.SaveAs("doc1.pdf");
// Create second PDF
var pdf2 = renderer.RenderHtmlAsPdf("<h1>Second Document</h1>");
pdf2.SaveAs("doc2.pdf");
// Merge PDFs
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
}
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
// Create first PDF
var pdf1 = renderer.RenderHtmlAsPdf("<h1>First Document</h1>");
pdf1.SaveAs("doc1.pdf");
// Create second PDF
var pdf2 = renderer.RenderHtmlAsPdf("<h1>Second Document</h1>");
pdf2.SaveAs("doc2.pdf");
// Merge PDFs
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
HiQPdf nécessite d'abord d'enregistrer les PDF sur le disque, de les charger avec PdfDocument.FromFile(), puis d'utiliser AddDocument() pour les ajouter les uns aux autres, et enfin WriteToFile() pour enregistrer le résultat. Ce document modifie le premier document en place.
IronPDF peut fusionner des documents directement en mémoire à l'aide de la méthode statique PdfDocument.Merge(), qui renvoie un nouveau document fusionné. Cette approche est plus propre et ne nécessite pas d'E/S de fichiers intermédiaires.
En-têtes et pieds de page avec numéros de page
La configuration de l'en-tête et du pied de page montre les différentes approches du contenu dynamique.
HiQPdf :
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
HtmlToPdf htmlToPdfConverter = new HtmlToPdf();
// Add header
htmlToPdfConverter.Document.Header.Height = 50;
HtmlToPdfVariableElement headerHtml = new HtmlToPdfVariableElement("<div style='text-align:center'>Page Header</div>", "");
htmlToPdfConverter.Document.Header.Add(headerHtml);
// Add footer with page number
htmlToPdfConverter.Document.Footer.Height = 50;
HtmlToPdfVariableElement footerHtml = new HtmlToPdfVariableElement("<div style='text-align:center'>Page {CrtPage} of {PageCount}</div>", "");
htmlToPdfConverter.Document.Footer.Add(footerHtml);
byte[] pdfBuffer = htmlToPdfConverter.ConvertHtmlToMemory("<h1>Document with Headers and Footers</h1>", "");
System.IO.File.WriteAllBytes("header-footer.pdf", pdfBuffer);
}
}
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
HtmlToPdf htmlToPdfConverter = new HtmlToPdf();
// Add header
htmlToPdfConverter.Document.Header.Height = 50;
HtmlToPdfVariableElement headerHtml = new HtmlToPdfVariableElement("<div style='text-align:center'>Page Header</div>", "");
htmlToPdfConverter.Document.Header.Add(headerHtml);
// Add footer with page number
htmlToPdfConverter.Document.Footer.Height = 50;
HtmlToPdfVariableElement footerHtml = new HtmlToPdfVariableElement("<div style='text-align:center'>Page {CrtPage} of {PageCount}</div>", "");
htmlToPdfConverter.Document.Footer.Add(footerHtml);
byte[] pdfBuffer = htmlToPdfConverter.ConvertHtmlToMemory("<h1>Document with Headers and Footers</h1>", "");
System.IO.File.WriteAllBytes("header-footer.pdf", pdfBuffer);
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
IronPDF :
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
// Configure header and footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
CenterText = "Page Header",
FontSize = 12
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
{
CenterText = "Page {page} of {total-pages}",
FontSize = 10
};
var pdf = renderer.RenderHtmlAsPdf("<h1>Document with Headers and Footers</h1>");
pdf.SaveAs("header-footer.pdf");
}
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
// Configure header and footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
CenterText = "Page Header",
FontSize = 12
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
{
CenterText = "Page {page} of {total-pages}",
FontSize = 10
};
var pdf = renderer.RenderHtmlAsPdf("<h1>Document with Headers and Footers</h1>");
pdf.SaveAs("header-footer.pdf");
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
HiQPdf configure les en-têtes et les pieds de page grâce aux propriétés Document.Header et Document.Footer, en définissant Height et en ajoutant des objets HtmlToPdfVariableElement. Les espaces réservés aux numéros de page utilisent {CrtPage}pour la page en cours et {PageCount}pour le nombre total de pages.
IronPDF utilise les objets RenderingOptions.TextHeader et RenderingOptions.TextFooter avec TextHeaderFooter. Des propriétés telles que CenterText et FontSize permettent une configuration directe. Les espaces réservés aux numéros de page utilisent {page}et {total-pages}.
Pour en savoir plus sur la configuration de l'en-tête et du pied de page, consultez les tutoriels IronPDF.
Référence de mappage d'API
Pour les développeurs qui évaluent la migration vers HiQPdfou qui comparent les capacités, cette correspondance montre les opérations équivalentes :
Mappage de la classe principale
| Classe HiQPdf | Classe IronPDF | Notes |
|---|---|---|
HtmlToPdf |
ChromePdfRenderer |
Classe de convertisseur principale |
Document PDF |
Document PDF |
Même nom, espace de noms différent |
PdfPage |
pdf.Pages[i] |
Accès via l'indexeur |
PdfDocumentControl |
Options de rendu |
Configuration |
PdfHeader / PdfDocumentHeader |
HtmlHeaderFooter |
Configurationde l'en-tête |
PdfFooter / PdfDocumentFooter |
HtmlHeaderFooter |
Configurationdu pied de page |
HtmlToPdfVariableElement |
HtmlHeaderFooter.HtmlFragment |
HTML dans les en-têtes/pieds de page |
Mise en correspondance des méthodes de conversion
| Méthode HiQPdf | Méthode IronPDF | Notes |
|---|---|---|
ConvertHtmlToMemory(html, baseUrl) |
RenderHtmlAsPdf(html, baseUrl) |
Retourne PdfDocument |
ConvertUrlToMemory(url) |
RenderUrlAsPdf(url) |
Retourne PdfDocument |
ConvertHtmlToFile(html, baseUrl, path) |
RenderHtmlAsPdf(html).SaveAs(path) |
Méthodes en chaîne |
ConvertUrlToFile(url, path) |
RenderUrlAsPdf(url).SaveAs(path) |
Méthodes en chaîne |
Cartographie des propriétés
| Propriété de HiQPdf | Propriété d'IronPDF | Notes |
|---|---|---|
Largeur du navigateur |
RenderingOptions.ViewPortWidth |
En pixels |
Hauteur du navigateur |
RenderingOptions.ViewPortHeight |
En pixels |
Document.PageSize |
RenderingOptions.PaperSize |
Utiliser enum |
Document.PageOrientation |
RenderingOptions.PaperOrientation |
Portrait/Paysage |
Document.Margins.Top |
RenderingOptions.MarginTop |
En mm (et non en points) |
Document.Margins.Bottom |
RenderingOptions.MarginBottom |
En mm |
Document.Margins.Left |
RenderingOptions.MarginLeft |
En mm |
Document.Margins.Right |
RenderingOptions.MarginRight |
En mm |
Document.Header.Height |
HtmlHeader.MaxHeight |
Hauteur de l'en-tête |
Document.Footer.Height |
HtmlFooter.MaxHeight |
Hauteur du pied de page |
Numéro de série |
IronPdf.License.LicenseKey |
Définir globalement |
Mappage de la syntaxe des caractères de remplacement
Les espaces réservés dans l'en-tête et le pied de page diffèrent d'une bibliothèque à l'autre :
| HiQPdf | IronPDF |
|---|---|
{CrtPage} |
{page} |
{PageCount} |
{total-pages} |
{CrtPageUri} |
{url} |
{CrtPageTitle} |
{html-title} |
Résumé de la comparaison des fonctionnalités
| Fonction | HiQPdf | IronPDF |
|---|---|---|
| Rendu de Chromium | ❌ (WebKit) | ✅ |
| JavaScript moderne (React, Angular, Vue) | ⚠️ Limited | ✅ |
| Prise en charge complète de CSS3 | ⚠️ Partiel | ✅ |
| prise en charge de .NET 6/7/8/9/10 | ⚠️ Documentation peu claire | ✅ |
| Paquet NuGet unique | ❌ (Plusieurs variantes) | ✅ |
| Essai complet gratuit | ❌ (limite de 3 pages + filigrane) | ✅(30 jours) |
| HTML vers PDF | ✅ | ✅ |
| URL vers PDF | ✅ | ✅ |
| Fusion de PDF | ✅(AddDocument) |
✅(Fusion) |
| En-têtes/Pieds de page | ✅(HtmlToPdfVariableElement) |
✅(TextHeaderFooter) |
Quand les équipes envisagent de passer de HiQPdfà IronPDF
Les équipes de développement évaluent la transition de HiQPdfàIronPDFpour plusieurs raisons :
<Version gratuite restrictive : La version gratuite de HiQPdfimpose une limite de 3 pages avec des filigranes intrusifs, ce qui la rend essentiellement inutilisable pour la production et difficile à évaluer en profondeur.IronPDFpropose une version d'essai complète de 30 jours sans limite de pages.
Moteur WebKit plus ancien : Le moteur de rendu de HiQPdfbasé sur WebKit a du mal avec les frameworks JavaScript modernes tels que React, Angular et Vue. Le moteur Chrome d'IronPDF offre la même qualité de rendu que Google Chrome, garantissant une conversion précise des contenus web modernes complexes.
Un support .NET Core peu clair : la documentation de HiQPdfne clarifie pas explicitement le support de .NET Core ou .NET 5+, et la bibliothèque nécessite des packages NuGet distincts pour les différentes plateformes.IronPDFpropose un package unifié unique avec une prise en charge documentée de .NET 6, 7, 8, 9 et 10.
Packages NuGet fragmentés : HiQPdfnécessite différentes variantes de packages (HiQPdf, HiQPdf.Free, HiQPdf.NetCore, HiQPdf.NetCore.x64, HiQPdf.Client) pour différents scénarios.IronPDFutilise un package unique pour toutes les plateformes.
Conception complexe de l'API : HiQPdfnécessite une configuration verbeuse à travers des chaînes de propriétés telles que Document.Header.Heightet Document.Footer.Add(). L'API fluide d'IronPDF avec les propriétés Options de rendupermet une configuration plus propre.
Syntaxe des espaces réservés différente : HiQPdfutilise les espaces réservés {CrtPage}et {PageCount}, tandis qu'IronPdf utilise {page}et {total-pages}. La migration nécessite la mise à jour de tous les modèles d'en-tête et de pied de page.
Forces et considérations
HiQPdfPoints forts
- Support HTML5/CSS3 : Fournit des capacités de rendu HTML5 et CSS3
- Bibliothèque établie : Bibliothèque commerciale avec une base d'utilisateurs existante
Considérations relatives à HiQPdf
- moteur WebKit : Ancienne technologie de rendu avec une prise en charge limitée du JavaScript moderne
- Limite de 3 pages : La version gratuite est considérablement limitée
- Paquets fragmentés : Plusieurs packages NuGet pour différentes plateformes
- Mauvaise prise en charge de .NET : La documentation ne clarifie pas explicitement la compatibilité moderne avec .NET
- Chaînes de propriétés complexes : Configurationverbeuse grâce à des propriétés imbriquées
- Unités basées sur les points : Utilise des points (72 par pouce) pour les mesures
Les points forts d'IronPDF
- Moteur Chrome : Rendu moderne avec prise en charge complète de JavaScript
- Paquet unifié : Paquet NuGet unique pour toutes les plateformes
- Essai complet : Essai complet de 30 jours
- <Prise en charge moderne de .NET : Documenté pour .NET 6, 7, 8, 9, 10
- Clean API : Configurationfluide des
RenderingOptions - Ressources complètes : tutoriels et documentation exhaustifs
Considérations relatives à IronPDF
- Licence commerciale : Nécessaire pour une utilisation en production
- Unités millimétriques : Utilise des millimètres plutôt que des points pour les marges
Conclusion
HiQPdf etIronPDFreprésentent différentes générations de la technologie HTML-to-PDF dans les applications .NET. Le moteur de HiQPdfbasé sur WebKit fournit un support HTML5/CSS3 de base, mais a du mal avec les frameworks JavaScript modernes et offre une compatibilité .NET Core peu claire avec de multiples paquets fragmentés. La limite de 3 pages de la version gratuite restreint considérablement l'évaluation.
IronPDF offre une alternative moderne basée sur Chromium avec un support JavaScript complet pour les applications React, Angular et Vue. Le package NuGet unique et unifié, avec une prise en charge documentée de .NET 6/7/8/9/10, simplifie le déploiement, et la conception épurée de l'API réduit la complexité de la configuration.
Alors que les organisations planifient .NET 10, C# 14 et le développement d'applications jusqu'en 2026, le choix entre l'ancien rendu WebKit avec des paquets fragmentés et le rendu moderne Chromium avec un support unifié a un impact significatif à la fois sur la vitesse de développement et sur la qualité des résultats. Les équipes qui ont besoin de la prise en charge d'un cadre JavaScript moderne, d'une compatibilité .NET claire ou d'une gestion rationalisée des paquets trouveront qu'IronPDF répond à ces exigences de manière efficace.
Commencez à évaluerIronPDFavec un essai gratuit et explorez la documentation complète pour évaluer l'adéquation à vos besoins spécifiques.