Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Comparaisons de produits
  4. Gembox.Pdf
COMPARAISONS DE PRODUITS

IronPDF vs GemBox.Pdf : Guide complet de comparaison de bibliothèques PDF .NET pour la conversion HTML en PDF

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
Mis à jour:

Lors du développement d'applications .NET nécessitant la génération et la manipulation de PDF, choisir la bonne bibliothèque C# PDF peut avoir un impact significatif sur le succès de votre projet. Cette comparaison complète examine IronPDF et GemBox.Pdf, deux bibliothèques PDF .NET proéminentes, pour aider les développeurs à prendre une décision éclairée en s'appuyant sur les fonctionnalités, les performances, les prix et les cas d'utilisation réels.

Aperçu rapide de la comparaison

class="product__comprehensive-comparison-table">
class="table-container">
class="table-number">Aperçu de la Comparaison des Produits
class="table-title">Comparaison des fonctionnalités d'IronPDF et de GemBox.Pdf pour le développement .NET
Catégorie Caractéristique/Aspect IronPDF GemBox.Pdf Avantage clé
Architecture de base Philosophie de conception HTML-prioritaire, rendu Chrome Manipulation native des PDF Dépendant du contexte
Complexité de l'API Méthodes simples comme RenderHtmlAsPdf() Objets PDF bas niveau IronPDF : Développement plus rapide
courbe d'apprentissage 1 à 2 jours typiques 3 à 5 jours typiques IronPDF : Adoption plus rapide
Support des plateformes Multi-plateforme Windows, Linux, macOS, Docker Windows, Linux, macOS, Android, iOS GemBox : Support mobile
Versions .NET .NET 10, 9, 8, 7, 6, 5, Core 3.1+, Framework 4.6.2+ .NET 6, Standard 2.0, Framework 3.5+ IronPDF : Support des dernières versions .NET
Plateformes cloud Optimisé pour Azure/AWS Support cloud standard IronPDF : Prêt pour le cloud
HTML à PDF Moteur de rendu Moteur complet Chrome V8 Pas de support HTML intégré* IronPDF : HTML à PDF natif
Support CSS3/HTML5 Support complet Nécessite GemBox.Document IronPDF : Normes web modernes
Exécution JavaScript Support complet JavaScript Pas de support JavaScript IronPDF : Contenu dynamique
Vitesse de rendu ~125ms typiques N/A (pas de support HTML) IronPDF : Rendu rapide
Expérience développeur Exemples de code 100+ exemples prêts à l'emploi 100+ exemples disponibles Les deux : Ressources étendues
Documentation Tutoriels, how-tos, vidéos Documentation API centrée IronPDF : Multiples chemins d'apprentissage
Manipulation de contenu Fusion/Séparation de PDF Méthodes intégrées Méthodes intégrées Les deux : Caractéristiques standard
Extraction de texte Support Unicode, intégration OCR Support Unicode, OCR intégré GemBox : OCR intégré
Support des formulaires Formulaires HTML vers PDF Créer, remplir, aplanir les formulaires Dépendant du contexte
Métriques de performance Utilisation de la mémoire En dessous de 10MB typiques Empreinte mémoire faible Les deux : Efficace
Support du multithreading Async/await natif optimisé Opérations sécurisées en thread IronPDF : Meilleur support async
Sécurité & Chiffrement Niveaux de chiffrement AES-256, gestionnaires personnalisés AES-256 standard Les deux : Norme de l'industrie
Signatures digitales Signatures visuelles intégrées Support de la signature numérique Les deux : Support des signatures
Licences & Tarification Niveau d'entrée Lite : $799 (1 dev, 1 projet) Dev unique : 0 (1 dev, projets illimités) IronPDF : Coût d'entrée inférieur
Redistribution +,999 sans redevance Inclus, déploiements illimités GemBox : Meilleures conditions de déploiement
Option de suite Iron Suite : $1,498 (9 produits) GemBox Bundle : ,200 (7 produits) IronPDF : Meilleure valeur de suite
Support Support inclus Oui, support ingénierie 24/5 Oui, support professionnel 1 an Les deux : Bon support
Délai de réponse 24-48 heures typiques Dans 1 jour ouvrable Les deux : Réponse rapide
Meilleur pour Cas d'utilisation HTML vers PDF, applications web, rapports Manipulation de PDF, formulaires, OCR Dépendant du contexte
class="table-note"> Note. GemBox.Pdf se concentre sur la manipulation de PDF et nécessite GemBox.Document pour la conversion HTML. IronPDF propose une conversion HTML vers PDF native avec rendu complet du navigateur. *Le support HTML dans GemBox nécessite l'achat d'un produit complémentaire.

Veuillez noterGemBox.Pdf nécessite la bibliothèque distincte GemBox.Document (890 $ en supplément) pour la conversion HTML en PDF.

Qu'est-ce que la bibliothèque IronPDF ?

IronPDF se distingue comme une bibliothèque .NET PDF complète spécifiquement conçue pour rendre la conversion HTML en PDF transparente pour les développeurs. Construit avec un moteur de rendu Chrome en son cœur, IronPDF transforme la façon dont les développeurs abordent la génération de PDF dans les applications C#, F# et VB.NET.

La philosophie de la bibliothèque se concentre sur l'exploitation des compétences existantes en développement Web. Au lieu d'apprendre des API PDF complexes, les développeurs peuvent utiliser le HTML, CSS et JavaScript familiers pour créer des documents PDF sophistiqués. Cette approche réduit considérablement le temps de développement tout en assurant un rendu fidèle au pixel qui répond aux normes web modernes.

Principales fonctionnalités d'IronPDF

IronPDF offre un ensemble de fonctionnalités étendu qui couvre pratiquement toutes les tâches liées au PDF que les développeurs pourraient rencontrer :

Excellence de la conversion HTML en PDF

  • Moteur Chrome V8: Rend le HTML en utilisant le même moteur que Google Chrome, assurant une fidélité du navigateur à plus de 98%
  • Support complet CSS3/HTML5: Support complet des normes web modernes, y compris flexbox, grid, et animations
  • Exécution JavaScript: Traite JavaScript avant le rendu, capturant parfaitement le contenu dynamique
  • Design Responsive: Gère les mises en page réactives avec des réglages de viewport personnalisables
  • Support des polices Web: Rend précisément les polices Google, les polices personnalisées et les polices d'icônes

Manipulation avancée de PDF

Sécurité et conformité

  • Chiffrement: Chiffrement AES-256 avec paramètres de permission personnalisés
  • Compliance PDF/A: Générer des PDF de qualité archivage pour un stockage à long terme
  • Rédaction: Supprimez de manière permanente le contenu sensible
  • Protection par mot de passe: Support des mots de passe utilisateur et propriétaire avec des permissions granuleuses

Exemple de code IronPDF : HTML en PDF avec fonctionnalités avancées

using IronPdf;
using IronPdf.Rendering;

// Configure the Chrome renderer with advanced options
var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        // Set paper orientation and size
        PaperOrientation = PdfPaperOrientation.Portrait,
        PaperSize = PdfPaperSize.A4,

        // Configure margins (in millimeters)
        MarginTop = 25,
        MarginBottom = 25,
        MarginLeft = 20,
        MarginRight = 20,

        // Enable JavaScript execution
        EnableJavaScript = true,
        RenderDelay = 1000, // Wait 1 second for JS to complete

        // Print background colors and images
        PrintHtmlBackgrounds = true,

        // Create PDF forms from HTML form elements
        CreatePdfFormsFromHtml = true,

        // Custom header and footer
        HtmlHeader = new HtmlHeaderFooter
        {
            Height = 20,
            HtmlFragment = "<div style='text-align: center; font-size: 12px;'>Company Report - {page} of {total-pages}</div>",
            DrawDividerLine = true
        },

        HtmlFooter = new HtmlHeaderFooter
        {
            Height = 15,
            HtmlFragment = "<div style='text-align: center; font-size: 10px;'>© 2025 Company Name. Confidential.</div>"
        }
    }
};

// Convert complex HTML with CSS and JavaScript
string htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: 'Segoe UI', Arial, sans-serif; line-height: 1.6; }
        .invoice-header { 
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 30px;
            border-radius: 10px;
            margin-bottom: 30px;
        }
        .data-table { 
            width: 100%; 
            border-collapse: collapse; 
            margin-top: 20px;
        }
        .data-table th { 
            background-color: #f8f9fa; 
            padding: 12px; 
            text-align: left;
            border-bottom: 2px solid #dee2e6;
        }
        .data-table td { 
            padding: 10px; 
            border-bottom: 1px solid #dee2e6;
        }
        .total-section {
            margin-top: 30px;
            text-align: right;
            font-size: 18px;
            font-weight: bold;
        }
        @media print {
            .no-print { display: none; }
        }
    </style>
</head>
<body>
    <div class='invoice-header'>
        <h1>Invoice #INV-2025-001</h1>
        <p>Date: <span id='current-date'></span></p>
    </div>

    <table class='data-table'>
        <thead>
            <tr>
                <th>Item Description</th>
                <th>Quantity</th>
                <th>Unit Price</th>
                <th>Total</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>Professional PDF Library License</td>
                <td>1</td>
                <td>$799.00</td>
                <td>$799.00</td>
            </tr>
            <tr>
                <td>Priority Support (1 Year)</td>
                <td>1</td>
                <td>$299.00</td>
                <td>$299.00</td>
            </tr>
        </tbody>
    </table>

    <div class='total-section'>
        <p>Subtotal: $1,048.00</p>
        <p>Tax (8%): $83.84</p>
        <p style='color: #667eea; font-size: 24px;'>Total: $1,131.84</p>
    </div>

    <script>
        // Dynamic date insertion
        document.getElementById('current-date').textContent = new Date().toLocaleDateString('en-US', {
            year: 'numeric',
            month: 'long',
            day: 'numeric'
        });
    </script>
</body>
</html>";

// Render the HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Apply additional security settings
pdf.SecuritySettings.OwnerPassword = "admin123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserFormData = true;

// Add metadata
pdf.MetaData.Author = "Invoice System";
pdf.MetaData.Title = "Invoice INV-2025-001";
pdf.MetaData.Subject = "Customer Invoice";
pdf.MetaData.Keywords = "invoice, payment, 2025";
pdf.MetaData.CreationDate = DateTime.Now;

// Save the PDF
pdf.SaveAs("invoice-2025-001.pdf");

// Optional: Save as PDF/A for archival
pdf.SaveAsPdfA("invoice-2025-001-archive.pdf", PdfAVersions.PdfA3);
using IronPdf;
using IronPdf.Rendering;

// Configure the Chrome renderer with advanced options
var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        // Set paper orientation and size
        PaperOrientation = PdfPaperOrientation.Portrait,
        PaperSize = PdfPaperSize.A4,

        // Configure margins (in millimeters)
        MarginTop = 25,
        MarginBottom = 25,
        MarginLeft = 20,
        MarginRight = 20,

        // Enable JavaScript execution
        EnableJavaScript = true,
        RenderDelay = 1000, // Wait 1 second for JS to complete

        // Print background colors and images
        PrintHtmlBackgrounds = true,

        // Create PDF forms from HTML form elements
        CreatePdfFormsFromHtml = true,

        // Custom header and footer
        HtmlHeader = new HtmlHeaderFooter
        {
            Height = 20,
            HtmlFragment = "<div style='text-align: center; font-size: 12px;'>Company Report - {page} of {total-pages}</div>",
            DrawDividerLine = true
        },

        HtmlFooter = new HtmlHeaderFooter
        {
            Height = 15,
            HtmlFragment = "<div style='text-align: center; font-size: 10px;'>© 2025 Company Name. Confidential.</div>"
        }
    }
};

// Convert complex HTML with CSS and JavaScript
string htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: 'Segoe UI', Arial, sans-serif; line-height: 1.6; }
        .invoice-header { 
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 30px;
            border-radius: 10px;
            margin-bottom: 30px;
        }
        .data-table { 
            width: 100%; 
            border-collapse: collapse; 
            margin-top: 20px;
        }
        .data-table th { 
            background-color: #f8f9fa; 
            padding: 12px; 
            text-align: left;
            border-bottom: 2px solid #dee2e6;
        }
        .data-table td { 
            padding: 10px; 
            border-bottom: 1px solid #dee2e6;
        }
        .total-section {
            margin-top: 30px;
            text-align: right;
            font-size: 18px;
            font-weight: bold;
        }
        @media print {
            .no-print { display: none; }
        }
    </style>
</head>
<body>
    <div class='invoice-header'>
        <h1>Invoice #INV-2025-001</h1>
        <p>Date: <span id='current-date'></span></p>
    </div>

    <table class='data-table'>
        <thead>
            <tr>
                <th>Item Description</th>
                <th>Quantity</th>
                <th>Unit Price</th>
                <th>Total</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>Professional PDF Library License</td>
                <td>1</td>
                <td>$799.00</td>
                <td>$799.00</td>
            </tr>
            <tr>
                <td>Priority Support (1 Year)</td>
                <td>1</td>
                <td>$299.00</td>
                <td>$299.00</td>
            </tr>
        </tbody>
    </table>

    <div class='total-section'>
        <p>Subtotal: $1,048.00</p>
        <p>Tax (8%): $83.84</p>
        <p style='color: #667eea; font-size: 24px;'>Total: $1,131.84</p>
    </div>

    <script>
        // Dynamic date insertion
        document.getElementById('current-date').textContent = new Date().toLocaleDateString('en-US', {
            year: 'numeric',
            month: 'long',
            day: 'numeric'
        });
    </script>
</body>
</html>";

// Render the HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Apply additional security settings
pdf.SecuritySettings.OwnerPassword = "admin123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserFormData = true;

// Add metadata
pdf.MetaData.Author = "Invoice System";
pdf.MetaData.Title = "Invoice INV-2025-001";
pdf.MetaData.Subject = "Customer Invoice";
pdf.MetaData.Keywords = "invoice, payment, 2025";
pdf.MetaData.CreationDate = DateTime.Now;

// Save the PDF
pdf.SaveAs("invoice-2025-001.pdf");

// Optional: Save as PDF/A for archival
pdf.SaveAsPdfA("invoice-2025-001-archive.pdf", PdfAVersions.PdfA3);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Cet exemple démontre la capacité d'IronPDF à gérer des mises en page HTML complexes avec des dégradés, des tableaux, un contenu JavaScript dynamique et des fonctionnalités PDF avancées telles que les paramètres de sécurité et les métadonnées. La bibliothèque traite tout de manière transparente, produisant un PDF professionnel qui correspond exactement au design HTML.

Qu'est-ce que la bibliothèque GemBox.Pdf ?

GemBox.Pdf représente une approche différente de la manipulation des PDF dans .NET. Plutôt que de se concentrer sur la conversion HTML en PDF, GemBox.Pdf se spécialise dans les opérations PDF bas niveau et la manipulation directe de PDF. Cela le rend particulièrement adapté aux scénarios où les développeurs ont besoin d'un contrôle précis sur la structure et le contenu PDF.

La bibliothèque excelle à travailler avec des documents PDF existants, offrant des fonctionnalités robustes pour lire, éditer et manipuler des fichiers PDF à un niveau granulaire. GemBox.Pdf fonctionne sans dépendances sur Adobe Acrobat, rendant le déploiement simple dans divers environnements.

Principales caractéristiques de GemBox.Pdf

GemBox.Pdf offre des capacités de manipulation de PDF complètes :

Opérations sur les documents PDF

  • Lire et écrire des PDF: Accès direct à la structure et au contenu des PDF
  • Fusionner et diviser: Combinez plusieurs PDF ou extrayez des pages spécifiques
  • Cloner les pages: Importez des pages entre différents documents PDF
  • Gestion des pages: Ajoutez, supprimez ou réorganisez les pages par programmation

Extraction et manipulation de contenu

  • Extraction de texte: Extrait du texte Unicode avec des informations de positionnement
  • Extraction d'images: Récupère des images intégrées dans des documents PDF
  • Support OCR: Reconnaissance optique de caractères intégrée pour documents scannés
  • Rédaction de contenu: Supprime définitivement les informations sensibles

Formulaires et interactivité

  • Formulaires interactifs: Créez, remplissez, aplanissez et exportez des formulaires PDF
  • Gestion des champs de formulaire: Accès programmatique à tous les types de champs de formulaire
  • Annotations: Ajoutez des hyperliens et autres annotations PDF

Graphiques et éléments visuels

  • Opérations de dessin: Ajoutez du texte, des images et des graphiques vectoriels
  • Formes et tracés: Créez des dessins vectoriels complexes
  • Filigranes: Appliquez des filigranes textes et images
  • Groupes de contenu: Organisez le contenu en groupes logiques

Exemple de code GemBox.Pdf : Manipulation de PDF et formulaires

using GemBox.Pdf;
using GemBox.Pdf.Content;
using GemBox.Pdf.Forms;
using GemBox.Pdf.Security;

// Set license (use FREE-LIMITED-KEY for evaluation)
ComponentInfo.SetLicense("FREE-LIMITED-KEY");

// Create a new PDF document from scratch
using (var document = new PdfDocument())
{
    // Add a page with custom size
    var page = document.Pages.Add();

    // Create formatted text with multiple styles
    using (var formattedText = new PdfFormattedText())
    {
        formattedText.FontSize = 24;
        formattedText.FontFamily = new PdfFontFamily("Arial");
        formattedText.Color = PdfColor.FromRgb(0.2, 0.2, 0.6);
        formattedText.AppendLine("GemBox.Pdf Document Example");

        formattedText.FontSize = 12;
        formattedText.Color = PdfColor.FromRgb(0, 0, 0);
        formattedText.AppendLine("This document demonstrates PDF creation and manipulation features.");

        // Draw text to the page
        page.Content.DrawText(formattedText, new PdfPoint(50, 700));
    }

    // Add a form to the document
    var form = document.Form;

    // Create text field
    var textField = form.Fields.AddText(page, 50, 600, 200, 30);
    textField.Name = "CustomerName";
    textField.Value = "Enter your name";
    textField.Format.Fill.Color = PdfColor.FromRgb(0.95, 0.95, 0.95);

    // Create checkbox
    var checkBox = form.Fields.AddCheck(page, 50, 550, 20, 20);
    checkBox.Name = "Agreement";
    checkBox.Checked = false;

    // Add descriptive text next to checkbox
    using (var checkboxLabel = new PdfFormattedText())
    {
        checkboxLabel.Append("I agree to the terms and conditions");
        page.Content.DrawText(checkboxLabel, new PdfPoint(80, 555));
    }

    // Create submit button
    var submitButton = form.Fields.AddButton(page, 50, 500, 100, 30);
    submitButton.Name = "Submit";
    submitButton.Actions.Activate = PdfActionType.Named;

    // Add button appearance
    using (var buttonText = new PdfFormattedText())
    {
        buttonText.Append("Submit Form");
        buttonText.FontSize = 14;
        buttonText.Color = PdfColor.FromRgb(1, 1, 1);

        // Create button appearance stream
        var appearance = submitButton.Appearance.Normal;
        appearance.Fill.Color = PdfColor.FromRgb(0.2, 0.4, 0.8);
        appearance.Stroke.Color = PdfColor.FromRgb(0.1, 0.2, 0.4);
        appearance.Stroke.Width = 1;

        // Draw button background
        appearance.DrawRectangle(new PdfPoint(0, 0), new PdfSize(100, 30), true, true);

        // Draw button text
        appearance.DrawText(buttonText, new PdfPoint(20, 10));
    }

    // Add a table using low-level graphics
    var tableTop = 400;
    var tableLeft = 50;
    var cellWidth = 150;
    var cellHeight = 30;

    // Draw table headers
    page.Content.DrawRectangle(new PdfPoint(tableLeft, tableTop), 
        new PdfSize(cellWidth * 3, cellHeight), true, true);

    using (var headerText = new PdfFormattedText())
    {
        headerText.FontSize = 12;
        headerText.Color = PdfColor.FromRgb(1, 1, 1);
        headerText.Append("Product");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + 10, tableTop + 10));

        headerText.Clear();
        headerText.Append("Quantity");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + cellWidth + 10, tableTop + 10));

        headerText.Clear();
        headerText.Append("Price");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + cellWidth * 2 + 10, tableTop + 10));
    }

    // Draw table data rows
    var rowData = new[]
    {
        new { Product = "PDF Library", Quantity = "1", Price = "$890" },
        new { Product = "Support Plan", Quantity = "1", Price = "$299" },
        new { Product = "Training", Quantity = "2", Price = "$500" }
    };

    var currentY = tableTop - cellHeight;
    foreach (var row in rowData)
    {
        // Draw cell borders
        page.Content.DrawRectangle(new PdfPoint(tableLeft, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);
        page.Content.DrawRectangle(new PdfPoint(tableLeft + cellWidth, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);
        page.Content.DrawRectangle(new PdfPoint(tableLeft + cellWidth * 2, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);

        // Draw cell content
        using (var cellText = new PdfFormattedText())
        {
            cellText.FontSize = 11;
            cellText.Append(row.Product);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + 10, currentY + 10));

            cellText.Clear();
            cellText.Append(row.Quantity);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + cellWidth + 10, currentY + 10));

            cellText.Clear();
            cellText.Append(row.Price);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + cellWidth * 2 + 10, currentY + 10));
        }

        currentY -= cellHeight;
    }

    // Apply security settings
    var securitySettings = document.SecuritySettings;
    securitySettings.DocumentOpenPassword = "user123";
    securitySettings.PermissionsPassword = "owner123";
    securitySettings.Permissions = PdfPermissions.AllowPrint | PdfPermissions.AllowFormFill;

    // Save the document
    document.Save("gembox-example.pdf");
}

// Example: Manipulating existing PDF
using (var existingDoc = PdfDocument.Load("existing-document.pdf"))
{
    // Extract text from first page
    var page = existingDoc.Pages[0];
    var text = page.Content.GetText();
    Console.WriteLine($"Extracted text: {text}");

    // Add watermark to all pages
    foreach (var p in existingDoc.Pages)
    {
        using (var watermark = new PdfFormattedText())
        {
            watermark.Append("CONFIDENTIAL");
            watermark.FontSize = 50;
            watermark.Color = PdfColor.FromRgb(0.5, 0.5, 0.5);
            watermark.Opacity = 0.3;

            // Calculate center position
            var pageWidth = p.MediaBox.Width;
            var pageHeight = p.MediaBox.Height;
            var textWidth = watermark.Width;
            var textHeight = watermark.Height;

            var x = (pageWidth - textWidth) / 2;
            var y = (pageHeight - textHeight) / 2;

            // Draw watermark diagonally
            p.Content.SaveGraphicsState();
            p.Content.SetTransform(1, 0, 0, 1, x, y);
            p.Content.SetTransform(0.7071, 0.7071, -0.7071, 0.7071, 0, 0);
            p.Content.DrawText(watermark, new PdfPoint(0, 0));
            p.Content.RestoreGraphicsState();
        }
    }

    existingDoc.Save("watermarked-document.pdf");
}
using GemBox.Pdf;
using GemBox.Pdf.Content;
using GemBox.Pdf.Forms;
using GemBox.Pdf.Security;

// Set license (use FREE-LIMITED-KEY for evaluation)
ComponentInfo.SetLicense("FREE-LIMITED-KEY");

// Create a new PDF document from scratch
using (var document = new PdfDocument())
{
    // Add a page with custom size
    var page = document.Pages.Add();

    // Create formatted text with multiple styles
    using (var formattedText = new PdfFormattedText())
    {
        formattedText.FontSize = 24;
        formattedText.FontFamily = new PdfFontFamily("Arial");
        formattedText.Color = PdfColor.FromRgb(0.2, 0.2, 0.6);
        formattedText.AppendLine("GemBox.Pdf Document Example");

        formattedText.FontSize = 12;
        formattedText.Color = PdfColor.FromRgb(0, 0, 0);
        formattedText.AppendLine("This document demonstrates PDF creation and manipulation features.");

        // Draw text to the page
        page.Content.DrawText(formattedText, new PdfPoint(50, 700));
    }

    // Add a form to the document
    var form = document.Form;

    // Create text field
    var textField = form.Fields.AddText(page, 50, 600, 200, 30);
    textField.Name = "CustomerName";
    textField.Value = "Enter your name";
    textField.Format.Fill.Color = PdfColor.FromRgb(0.95, 0.95, 0.95);

    // Create checkbox
    var checkBox = form.Fields.AddCheck(page, 50, 550, 20, 20);
    checkBox.Name = "Agreement";
    checkBox.Checked = false;

    // Add descriptive text next to checkbox
    using (var checkboxLabel = new PdfFormattedText())
    {
        checkboxLabel.Append("I agree to the terms and conditions");
        page.Content.DrawText(checkboxLabel, new PdfPoint(80, 555));
    }

    // Create submit button
    var submitButton = form.Fields.AddButton(page, 50, 500, 100, 30);
    submitButton.Name = "Submit";
    submitButton.Actions.Activate = PdfActionType.Named;

    // Add button appearance
    using (var buttonText = new PdfFormattedText())
    {
        buttonText.Append("Submit Form");
        buttonText.FontSize = 14;
        buttonText.Color = PdfColor.FromRgb(1, 1, 1);

        // Create button appearance stream
        var appearance = submitButton.Appearance.Normal;
        appearance.Fill.Color = PdfColor.FromRgb(0.2, 0.4, 0.8);
        appearance.Stroke.Color = PdfColor.FromRgb(0.1, 0.2, 0.4);
        appearance.Stroke.Width = 1;

        // Draw button background
        appearance.DrawRectangle(new PdfPoint(0, 0), new PdfSize(100, 30), true, true);

        // Draw button text
        appearance.DrawText(buttonText, new PdfPoint(20, 10));
    }

    // Add a table using low-level graphics
    var tableTop = 400;
    var tableLeft = 50;
    var cellWidth = 150;
    var cellHeight = 30;

    // Draw table headers
    page.Content.DrawRectangle(new PdfPoint(tableLeft, tableTop), 
        new PdfSize(cellWidth * 3, cellHeight), true, true);

    using (var headerText = new PdfFormattedText())
    {
        headerText.FontSize = 12;
        headerText.Color = PdfColor.FromRgb(1, 1, 1);
        headerText.Append("Product");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + 10, tableTop + 10));

        headerText.Clear();
        headerText.Append("Quantity");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + cellWidth + 10, tableTop + 10));

        headerText.Clear();
        headerText.Append("Price");
        page.Content.DrawText(headerText, new PdfPoint(tableLeft + cellWidth * 2 + 10, tableTop + 10));
    }

    // Draw table data rows
    var rowData = new[]
    {
        new { Product = "PDF Library", Quantity = "1", Price = "$890" },
        new { Product = "Support Plan", Quantity = "1", Price = "$299" },
        new { Product = "Training", Quantity = "2", Price = "$500" }
    };

    var currentY = tableTop - cellHeight;
    foreach (var row in rowData)
    {
        // Draw cell borders
        page.Content.DrawRectangle(new PdfPoint(tableLeft, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);
        page.Content.DrawRectangle(new PdfPoint(tableLeft + cellWidth, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);
        page.Content.DrawRectangle(new PdfPoint(tableLeft + cellWidth * 2, currentY), 
            new PdfSize(cellWidth, cellHeight), false, true);

        // Draw cell content
        using (var cellText = new PdfFormattedText())
        {
            cellText.FontSize = 11;
            cellText.Append(row.Product);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + 10, currentY + 10));

            cellText.Clear();
            cellText.Append(row.Quantity);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + cellWidth + 10, currentY + 10));

            cellText.Clear();
            cellText.Append(row.Price);
            page.Content.DrawText(cellText, new PdfPoint(tableLeft + cellWidth * 2 + 10, currentY + 10));
        }

        currentY -= cellHeight;
    }

    // Apply security settings
    var securitySettings = document.SecuritySettings;
    securitySettings.DocumentOpenPassword = "user123";
    securitySettings.PermissionsPassword = "owner123";
    securitySettings.Permissions = PdfPermissions.AllowPrint | PdfPermissions.AllowFormFill;

    // Save the document
    document.Save("gembox-example.pdf");
}

// Example: Manipulating existing PDF
using (var existingDoc = PdfDocument.Load("existing-document.pdf"))
{
    // Extract text from first page
    var page = existingDoc.Pages[0];
    var text = page.Content.GetText();
    Console.WriteLine($"Extracted text: {text}");

    // Add watermark to all pages
    foreach (var p in existingDoc.Pages)
    {
        using (var watermark = new PdfFormattedText())
        {
            watermark.Append("CONFIDENTIAL");
            watermark.FontSize = 50;
            watermark.Color = PdfColor.FromRgb(0.5, 0.5, 0.5);
            watermark.Opacity = 0.3;

            // Calculate center position
            var pageWidth = p.MediaBox.Width;
            var pageHeight = p.MediaBox.Height;
            var textWidth = watermark.Width;
            var textHeight = watermark.Height;

            var x = (pageWidth - textWidth) / 2;
            var y = (pageHeight - textHeight) / 2;

            // Draw watermark diagonally
            p.Content.SaveGraphicsState();
            p.Content.SetTransform(1, 0, 0, 1, x, y);
            p.Content.SetTransform(0.7071, 0.7071, -0.7071, 0.7071, 0, 0);
            p.Content.DrawText(watermark, new PdfPoint(0, 0));
            p.Content.RestoreGraphicsState();
        }
    }

    existingDoc.Save("watermarked-document.pdf");
}
Imports GemBox.Pdf
Imports GemBox.Pdf.Content
Imports GemBox.Pdf.Forms
Imports GemBox.Pdf.Security

' Set license (use FREE-LIMITED-KEY for evaluation)
ComponentInfo.SetLicense("FREE-LIMITED-KEY")

' Create a new PDF document from scratch
Using document = New PdfDocument()
	' Add a page with custom size
	Dim page = document.Pages.Add()

	' Create formatted text with multiple styles
	Using formattedText = New PdfFormattedText()
		formattedText.FontSize = 24
		formattedText.FontFamily = New PdfFontFamily("Arial")
		formattedText.Color = PdfColor.FromRgb(0.2, 0.2, 0.6)
		formattedText.AppendLine("GemBox.Pdf Document Example")

		formattedText.FontSize = 12
		formattedText.Color = PdfColor.FromRgb(0, 0, 0)
		formattedText.AppendLine("This document demonstrates PDF creation and manipulation features.")

		' Draw text to the page
		page.Content.DrawText(formattedText, New PdfPoint(50, 700))
	End Using

	' Add a form to the document
	Dim form = document.Form

	' Create text field
	Dim textField = form.Fields.AddText(page, 50, 600, 200, 30)
	textField.Name = "CustomerName"
	textField.Value = "Enter your name"
	textField.Format.Fill.Color = PdfColor.FromRgb(0.95, 0.95, 0.95)

	' Create checkbox
	Dim checkBox = form.Fields.AddCheck(page, 50, 550, 20, 20)
	checkBox.Name = "Agreement"
	checkBox.Checked = False

	' Add descriptive text next to checkbox
	Using checkboxLabel = New PdfFormattedText()
		checkboxLabel.Append("I agree to the terms and conditions")
		page.Content.DrawText(checkboxLabel, New PdfPoint(80, 555))
	End Using

	' Create submit button
	Dim submitButton = form.Fields.AddButton(page, 50, 500, 100, 30)
	submitButton.Name = "Submit"
	submitButton.Actions.Activate = PdfActionType.Named

	' Add button appearance
	Using buttonText = New PdfFormattedText()
		buttonText.Append("Submit Form")
		buttonText.FontSize = 14
		buttonText.Color = PdfColor.FromRgb(1, 1, 1)

		' Create button appearance stream
		Dim appearance = submitButton.Appearance.Normal
		appearance.Fill.Color = PdfColor.FromRgb(0.2, 0.4, 0.8)
		appearance.Stroke.Color = PdfColor.FromRgb(0.1, 0.2, 0.4)
		appearance.Stroke.Width = 1

		' Draw button background
		appearance.DrawRectangle(New PdfPoint(0, 0), New PdfSize(100, 30), True, True)

		' Draw button text
		appearance.DrawText(buttonText, New PdfPoint(20, 10))
	End Using

	' Add a table using low-level graphics
	Dim tableTop = 400
	Dim tableLeft = 50
	Dim cellWidth = 150
	Dim cellHeight = 30

	' Draw table headers
	page.Content.DrawRectangle(New PdfPoint(tableLeft, tableTop), New PdfSize(cellWidth * 3, cellHeight), True, True)

	Using headerText = New PdfFormattedText()
		headerText.FontSize = 12
		headerText.Color = PdfColor.FromRgb(1, 1, 1)
		headerText.Append("Product")
		page.Content.DrawText(headerText, New PdfPoint(tableLeft + 10, tableTop + 10))

		headerText.Clear()
		headerText.Append("Quantity")
		page.Content.DrawText(headerText, New PdfPoint(tableLeft + cellWidth + 10, tableTop + 10))

		headerText.Clear()
		headerText.Append("Price")
		page.Content.DrawText(headerText, New PdfPoint(tableLeft + cellWidth * 2 + 10, tableTop + 10))
	End Using

	' Draw table data rows
	Dim rowData = {
		New With {
			Key .Product = "PDF Library",
			Key .Quantity = "1",
			Key .Price = "$890"
		},
		New With {
			Key .Product = "Support Plan",
			Key .Quantity = "1",
			Key .Price = "$299"
		},
		New With {
			Key .Product = "Training",
			Key .Quantity = "2",
			Key .Price = "$500"
		}
	}

	Dim currentY = tableTop - cellHeight
	For Each row In rowData
		' Draw cell borders
		page.Content.DrawRectangle(New PdfPoint(tableLeft, currentY), New PdfSize(cellWidth, cellHeight), False, True)
		page.Content.DrawRectangle(New PdfPoint(tableLeft + cellWidth, currentY), New PdfSize(cellWidth, cellHeight), False, True)
		page.Content.DrawRectangle(New PdfPoint(tableLeft + cellWidth * 2, currentY), New PdfSize(cellWidth, cellHeight), False, True)

		' Draw cell content
		Using cellText = New PdfFormattedText()
			cellText.FontSize = 11
			cellText.Append(row.Product)
			page.Content.DrawText(cellText, New PdfPoint(tableLeft + 10, currentY + 10))

			cellText.Clear()
			cellText.Append(row.Quantity)
			page.Content.DrawText(cellText, New PdfPoint(tableLeft + cellWidth + 10, currentY + 10))

			cellText.Clear()
			cellText.Append(row.Price)
			page.Content.DrawText(cellText, New PdfPoint(tableLeft + cellWidth * 2 + 10, currentY + 10))
		End Using

		currentY -= cellHeight
	Next row

	' Apply security settings
	Dim securitySettings = document.SecuritySettings
	securitySettings.DocumentOpenPassword = "user123"
	securitySettings.PermissionsPassword = "owner123"
	securitySettings.Permissions = PdfPermissions.AllowPrint Or PdfPermissions.AllowFormFill

	' Save the document
	document.Save("gembox-example.pdf")
End Using

' Example: Manipulating existing PDF
Using existingDoc = PdfDocument.Load("existing-document.pdf")
	' Extract text from first page
	Dim page = existingDoc.Pages(0)
	Dim text = page.Content.GetText()
	Console.WriteLine($"Extracted text: {text}")

	' Add watermark to all pages
	For Each p In existingDoc.Pages
		Using watermark = New PdfFormattedText()
			watermark.Append("CONFIDENTIAL")
			watermark.FontSize = 50
			watermark.Color = PdfColor.FromRgb(0.5, 0.5, 0.5)
			watermark.Opacity = 0.3

			' Calculate center position
			Dim pageWidth = p.MediaBox.Width
			Dim pageHeight = p.MediaBox.Height
			Dim textWidth = watermark.Width
			Dim textHeight = watermark.Height

			Dim x = (pageWidth - textWidth) \ 2
			Dim y = (pageHeight - textHeight) \ 2

			' Draw watermark diagonally
			p.Content.SaveGraphicsState()
			p.Content.SetTransform(1, 0, 0, 1, x, y)
			p.Content.SetTransform(0.7071, 0.7071, -0.7071, 0.7071, 0, 0)
			p.Content.DrawText(watermark, New PdfPoint(0, 0))
			p.Content.RestoreGraphicsState()
		End Using
	Next p

	existingDoc.Save("watermarked-document.pdf")
End Using
$vbLabelText   $csharpLabel

Cet exemple met en avant la force de GemBox.Pdf dans la manipulation de PDF bas niveau, en démontrant la création de formulaires, le dessin graphique et les fonctionnalités de sécurité des documents. Bien que le code soit plus verbeux que l'approche HTML d'IronPDF, il offre un contrôle précis sur chaque aspect du PDF.

Comment ces bibliothèques gèrent-elles la conversion HTML en PDF ?

L'approche de la conversion HTML en PDF représente l'une des différences les plus significatives entre IronPDF et GemBox.Pdf.

Approche HTML vers PDF d'IronPDF

IronPDF a été développé dès le départ avec la conversion HTML en PDF comme objectif principal. La bibliothèque inclut un moteur de rendu Chrome complet qui traite le HTML, le CSS et le JavaScript exactement comme le ferait un navigateur Web. Cela signifie :

  • Véritable rendu de navigateur: Utilise le même moteur Blink que Google Chrome
  • Normes web complètes: Support complet du CSS3, HTML5, flexbox, grid, et JavaScript moderne
  • Contenu dynamique: Exécute JavaScript avant le rendu, capturant le contenu AJAX et les éléments dynamiques
  • Design Responsive: Gère les requêtes médias et les mises en page réactives
  • Ressources externes: Récupère automatiquement les images, feuilles de style et polices à partir des URLs

Support HTML limité de GemBox

GemBox.Pdf lui-même ne prend pas en charge la conversion HTML en PDF. Pour convertir du HTML en PDF avec GemBox, les développeurs doivent :

  1. Acheter séparément GemBox.Document (coût supplémentaire de 890 $)
  2. Utiliser GemBox.Document pour convertir HTML en DOCX
  3. Puis convertir DOCX en PDF

Cette approche présente des limitations importantes :

  • Pas de support JavaScript: Impossible de traiter le contenu dynamique
  • Support CSS limité: De nombreuses fonctionnalités CSS modernes ne sont pas prises en charge
  • Problèmes de style: Problèmes connus avec les bordures, les dispositions complexes comme noté dans les discussions Stack Overflow
  • Optimisé pour l'impression uniquement: Nécessite un HTML formaté spécifiquement pour impression
  • Coût supplémentaire: Nécessite l'achat de deux bibliothèques distinctes

Support des frameworks CSS modernes : une différence cruciale

L'un des avantages les plus significatifs du rendu basé sur Chrome d'IronPDF devient apparent lorsqu'on travaille avec des frameworks CSS modernes comme Bootstrap, Tailwind CSS, et Foundation. Ces frameworks sont devenus la colonne vertébrale des applications Web modernes, et leur capacité à bien s'afficher dans les PDF est essentielle pour de nombreux cas d'utilisation.

IronPDF : Support complet des frameworks modernes

Le moteur de rendu Chrome d'IronPDF fournit un support complet et natif pour tous les frameworks CSS modernes :

  • Bootstrap 5 : Support complet de flexbox et de la grille CSS pour les mises en page réactives
  • Tailwind CSS: Support complet du framework CSS utilitaire
  • Real-world examples: Renders the Bootstrap homepage and Bootstrap templates pixel-perfect
  • Fonctionnalités CSS3 modernes: Animations, transformations, transitions, propriétés personnalisées
  • Designs réactifs: Les requêtes médias et mises en page basées sur le viewport fonctionnent sans problème

Exemple de code : Formulaire Bootstrap vers PDF

using IronPdf;

var renderer = new ChromePdfRenderer();

string bootstrapForm = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
    <div class='container mt-5'>
        <h1 class='mb-4'>Customer Registration</h1>
        <form class='needs-validation'>
            <div class='row g-3'>
                <div class='col-md-6'>
                    <label class='form-label'>First Name</label>
                    <input type='text' class='form-control' value='John'>
                </div>
                <div class='col-md-6'>
                    <label class='form-label'>Last Name</label>
                    <input type='text' class='form-control' value='Smith'>
                </div>
            </div>
            <div class='mt-4'>
                <button class='btn btn-primary' type='submit'>Submit</button>
            </div>
        </form>
    </div>
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(bootstrapForm);
pdf.SaveAs("bootstrap-form.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

string bootstrapForm = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
    <div class='container mt-5'>
        <h1 class='mb-4'>Customer Registration</h1>
        <form class='needs-validation'>
            <div class='row g-3'>
                <div class='col-md-6'>
                    <label class='form-label'>First Name</label>
                    <input type='text' class='form-control' value='John'>
                </div>
                <div class='col-md-6'>
                    <label class='form-label'>Last Name</label>
                    <input type='text' class='form-control' value='Smith'>
                </div>
            </div>
            <div class='mt-4'>
                <button class='btn btn-primary' type='submit'>Submit</button>
            </div>
        </form>
    </div>
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(bootstrapForm);
pdf.SaveAs("bootstrap-form.pdf");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

GemBox : Pas de support des frameworks modernes

Comme GemBox.Pdf ne dispose pas de rendu HTML natif et doit s'appuyer sur GemBox.Document pour la conversion HTML, les frameworks CSS modernes rencontrent de sévères limitations :

  • Pas de support Bootstrap: Les fonctionnalités Flexbox et CSS Grid ne s'afficheront pas correctement
  • Pas de support Tailwind CSS: Les classes utilitaires et les mises en page modernes ne sont pas prises en charge
  • Solutions manuelles requises: Il faut créer des versions optimisées pour impression du HTML
  • CSS3 limité: De nombreuses fonctionnalités CSS modernes ne fonctionneront tout simplement pas
  • Complexité supplémentaire: Le processus de conversion en deux étapes (HTML → DOCX → PDF) introduit des incohérences

Selon les discussions des développeurs, même les fonctionnalités CSS de base comme les bordures et dispositions peuvent être problématiques avec l'approche de conversion HTML de GemBox.

Impact réel: Si votre application utilise Bootstrap pour son interface utilisateur et que vous avez besoin de générer des rapports ou des exports PDF qui correspondent à votre interface Web, IronPDF offre une solution simple tandis que GemBox nécessiterait une refonte significative ou des solutions manuelles.

Pour plus de détails sur la compatibilité du framework CSS, voir le Guide CSS Bootstrap & Flexbox.

Quelle bibliothèque excelle dans différentes tâches PDF ?

Comprendre où chaque bibliothèque excelle aide les développeurs à choisir l'outil adapté à leurs besoins spécifiques.

Où IronPDF excelle

IronPDF affiche des performances supérieures dans ces scénarios :

1. Génération de PDF pour applications web

Parfait pour les applications SaaS, portails web, et tout système nécessitant de convertir le contenu web en PDF. Le moteur de rendu Chrome garantit que les mises en page web complexes, y compris celles utilisant Bootstrap, Tailwind CSS, ou des frameworks personnalisés, s'affichent parfaitement.

2. Génération de rapports dynamiques

Lorsque les rapports incluent des graphiques (Chart.js, D3.js), de la visualisation de données dynamique, ou du contenu JavaScript rendu, IronPDF capture tout avec précision. Cela le rend idéal pour les tableaux de bord de veille économique et les applications basées sur des données.

3. Factures et modèles de documents

Utiliser des modèles HTML/CSS pour les factures, reçus, et documents commerciaux permet aux concepteurs de créer des modèles sans avoir à apprendre des API spécifiques aux PDF. Les modifications peuvent être effectuées rapidement en utilisant des technologies Web familières.

4. Projets de développement rapide

L'API simple et l'approche basée sur HTML réduisent considérablement le temps de développement. Un développeur peut créer un PDF complexe en quelques minutes, plutôt qu'en heures.

5. Déploiement multi-plateforme

Avec le support natif pour Windows, Linux, macOS, Docker, et les plateformes cloud, IronPDF simplifie le déploiement dans divers environnements.

Où GemBox.Pdf excelle

GemBox.Pdf montre ses points forts dans ces domaines :

1. Manipulation PDF bas niveau

Lorsque le contrôle précis de la structure PDF est requis, l'approche orientée objet de GemBox.Pdf offre un accès direct aux éléments, flux et dictionnaires PDF.

2. Applications orientées formulaires

Pour les applications travaillant intensivement avec des formulaires PDF, GemBox.Pdf propose une manipulation complète des champs de formulaire, y compris la création de formulaires interactifs complexes par programmation.

3. Besoins en OCR

Avec des capacités d'OCR intégrées, GemBox.Pdf peut extraire le texte de documents scannés sans nécessiter de bibliothèques supplémentaires, ce qui le rend adapté aux projets de numérisation de documents.

4. Développement mobile

Le support natif des plateformes Android et iOS fait de GemBox.Pdf un bon choix pour les applications mobiles nécessitant des fonctionnalités PDF.

5. Modification de PDF existants

Lorsque l'on travaille principalement avec des PDF existants plutôt que de générer de nouveaux, les outils de GemBox.Pdf pour l'extraction, la manipulation et la modification sont bien adaptés à la tâche.

Comment l'installation et la configuration se comparent-elles ?

Les deux bibliothèques offrent une installation simple via NuGet, mais avec des niveaux de complexité différents.

Installer IronPDF

L'installation d'IronPDF est remarquablement simple :

Install-Package IronPdf

Ou via le .NET CLI :

dotnet add package IronPdf

Le package inclut tout ce qui est nécessaire, y compris le moteur de rendu Chrome. Aucune configuration supplémentaire ou dépendance n'est requise pour la plupart des cas d'utilisation.

Pour des scénarios de déploiement spécifiques, IronPDF offre :

  • IronPdf.Slim: Package léger qui télécharge des composants spécifiques à la plateforme à l'exécution
  • IronPdf.Linux: Pré-configuré pour les déploiements Linux
  • IronPdf.MacOs: Optimisé pour les environnements macOS

Installation de GemBox.Pdf

L'installation de GemBox.Pdf est tout aussi simple pour la manipulation PDF de base :

Install-Package GemBox.Pdf

Cependant, pour la conversion HTML en PDF, vous aurez besoin de :

Install-Package GemBox.Document

Les deux bibliothèques nécessitent la configuration de clé de licence :

// IronPDF
License.LicenseKey = "YOUR-LICENSE-KEY";

// GemBox.Pdf
ComponentInfo.SetLicense("YOUR-LICENSE-KEY");
// IronPDF
License.LicenseKey = "YOUR-LICENSE-KEY";

// GemBox.Pdf
ComponentInfo.SetLicense("YOUR-LICENSE-KEY");
' IronPDF
License.LicenseKey = "YOUR-LICENSE-KEY"

' GemBox.Pdf
ComponentInfo.SetLicense("YOUR-LICENSE-KEY")
$vbLabelText   $csharpLabel

Quelles sont les différences de licence et de prix ?

Comprendre les modèles de licence permet de déterminer le coût total de possession pour chaque solution.

Licences IronPDF

IronPDF propose une tarification transparente et par niveaux (tarification de 2025) :

  • Licence Lite: $799
    • 1 an de support et de mises à jour
    • 1 développeur
    • 1 projet

  • Licence Plus: $1,199

  • Licence Professionnelle: $2,399
    • 3 développeurs
    • 3 projets
  • Licence Plus: $1,199

Options additionnelles :

  • Redistribution sans redevance : +$2,399
  • Licences SaaS/OEM disponibles
    • 10 développeurs
    • 10 projets

  • Licence Plus: $1,199

  • Iron Suite bundle : $1,498 pour 9 produits Bénéfices clés :
  • Garantie de remboursement de 30 jours
  • Licences perpétuelles (achat unique)

  • Développement et test gratuits

  • Déploiement sur dev/staging/production inclus

Licences GemBox.Pdf

GemBox offre une tarification par développeur :

  • Développeur unique : 890 $
    • Projets illimités
  • Déploiement sans redevance inclus

    • Considerations importantes :

    • HTML en PDF nécessite GemBox.Document : Coût supplémentaire de 890 $

    • Coût total pour HTML en PDF : 1,780 $ minimum

    • Réduction de 40% sur les renouvellements (60% si renouvelé avant expiration)
      • 1 développeur
    • GemBox Bundle : 2,200 $ pour 7 produits
    • Licence Plus: $1,199

    • Licences perpétuelles

    • Déploiement illimité inclus

    • Aucune licence serveur ou OEM requise

    Comparaison des coûts pour des scénarios courants

    Scénario Coût IronPDF

  • Déploiement sur dev/staging/production inclus

    • Licences GemBox.Pdf

    Coût GemBox 2,670 $ Développeur unique, HTML en PDF

    749 $

    |1,780 $|3 développeurs, manipulation PDF uniquement|1,499 $| |2,670 $|2,670 $----|2,670 $---| |3 développeurs, HTML en PDF|$1,199|5,340 $| |Entreprise (10 devs), fonctionnalités complètes|$2,399|8,900$+| |## Quelle bibliothèque devriez-vous choisir ?|Le choix entre IronPDF et GemBox.Pdf dépend de vos besoins spécifiques :|### Choisissez IronPDF lorsque :| |- HTML en PDF est une exigence principale : Le rendu basé sur Chrome d'IronPDF est inégalé|- Vous avez besoin d'un support web moderne : Capacités CSS3, HTML5 et JavaScript complètes|- Un développement rapide est important : L'API simple réduit le temps de mise sur le marché |

    • Vous travaillez avec du contenu dynamique : L'exécution JavaScript capture les données en temps réel

    • Le déploiement multi-plateforme est nécessaire : Excellent support pour le cloud et les environnements conteneurisés

    • Le budget est une considération : Coût d'entrée inférieur et meilleure valeur pour les scénarios HTML en PDF

    Choisissez GemBox.Pdf lorsque :

    • Un contrôle PDF bas niveau est essentiel : Accès direct aux objets et à la structure PDF
    • Le support des plateformes mobiles est requis : Compatibilité native Android et iOS
    • L'OCR est une exigence principale : OCR intégré sans dépendances supplémentaires
    • Vous travaillez principalement avec des PDF existants : Forte manipulation et fonctionnalités d'extraction

    • HTML en PDF n'est pas nécessaire : Évitez de payer pour GemBox.Document inutilisé

    • Le déploiement illimité est important : Redistribution sans redevance incluse

    Considérez l'utilisation des deux bibliothèques lorsque :

    Certaines organisations trouvent de la valeur à utiliser les deux bibliothèques pour différentes parties de leur application :

    • IronPDF pour la génération de rapports et la conversion HTML en PDF
    • GemBox.Pdf pour le traitement des formulaires et la manipulation de PDF

    Démarrer avec votre bibliothèque choisie

    Les deux bibliothèques offrent des essais gratuits pour évaluer leurs capacités :

    Essayez IronPDF

    1. Installez le package NuGet

    2. Pas besoin de clé de licence pour le développement

    3. Des filigranes apparaissent sur les PDF en mode essai
    4. Accès complet aux fonctionnalités pendant l'évaluation

    Téléchargez l'essai gratuit d'IronPDF

    Essayez GemBox.Pdf

    1. Utilisez ComponentInfo.SetLicense("FREE-LIMITED-KEY")

    2. Limité à 2 pages en mode gratuit

    3. Passez en mode complet pour supprimer les limitations

    Guide visuel d'installation

    Pour les développeurs préférant l'interface graphique de Visual Studio, voici un guide étape par étape pour installer les deux bibliothèques :

    Créer un projet ASP.NET

    Boîte de dialogue Projet Nouveau de Visual Studio affichant la sélection d'application Web ASP.NET avec options .NET Framework

    Boîte de dialogue Nouveau projet de Visual Studio pour créer une application web ASP.NET - la fondation pour les projets de génération de PDF

    1. Passez en mode complet pour supprimer les limitations Écran de sélection de modèle de projet ASP.NET mettant en évidence l'option Web Forms pour l'intégration de bibliothèque PDF Sélection de Web Forms comme modèle de projet - adapté pour les implémentations IronPDF et GemBox.Pdf

    Installer les bibliothèques PDF via NuGet

    Menu contextuel de l'explorateur de solutions montrant l'option Gérer les packages NuGet pour l'ajout de bibliothèques PDF

    Cliquez avec le bouton droit sur votre projet dans l'explorateur de solutions pour accéder au gestionnaire de packages NuGet pour l'installation de la bibliothèque

    Menu Projet de Visual Studio affichant l'option Gérer les packages NuGet pour l'installation de la bibliothèque PDF

    Accès alternatif au gestionnaire de packages NuGet via le menu Projet dans Visual Studio Interface du gestionnaire de packages NuGet montrant l'installation d'IronPDF avec détails de version et description

    Installation d'IronPDF via le gestionnaire de packages NuGet - notez la description complète des fonctionnalités et le nombre de téléchargements

    Méthodes d'installation alternatives

    Installing PDF Libraries via NuGet

    Solution Explorer context menu showing Manage NuGet Packages option for adding PDF libraries Right-click your project in Solution Explorer to access NuGet Package Manager for library installation

    Visual Studio Project menu displaying Manage NuGet Packages option for PDF library installation Alternative access to NuGet Package Manager through the Project menu in Visual Studio

    NuGet Package Manager interface showing IronPDF installation with version details and description Installing IronPDF through NuGet Package Manager - note the comprehensive feature description and download count

    Alternative Installation Methods

    Page de téléchargement officielle d'IronPDF montrant l'option de téléchargement direct du DLL pour une installation manuelle Le site Web d'IronPDF propose des téléchargements directs de DLL pour les scénarios où l'installation via NuGet n'est pas appropriée

    Conclusion

    IronPDF et GemBox.Pdf sont deux bibliothèques PDF de qualité pour les développeurs .NET, chacune ayant des forces distinctes. IronPDF excelle dans la conversion HTML en PDF avec son moteur de rendu Chrome, idéal pour les applications web modernes et la génération de contenu dynamique. GemBox.Pdf se distingue par sa manipulation PDF de bas niveau et son support mobile, parfait pour les applications nécessitant un contrôle précis des PDF.

    Pour la plupart des développeurs web et des équipes créant des applications modernes, IronPDF offre la meilleure combinaison de fonctionnalités, de facilité d'utilisation et de valeur. Sa capacité à rendre des PDF parfaitement pixelisés à partir de HTML en utilisant des technologies web familières réduit considérablement le temps de développement et la complexité.

    Cependant, GemBox.Pdf reste un choix solide pour les scénarios spécialisés, notamment le développement mobile et les applications axées sur le traitement des formulaires PDF ou les exigences OCR.

    Prêt à transformer votre contenu HTML en PDF professionnel ? Commencez avec l'essai gratuit d'IronPDF et découvrez la puissance du rendu de qualité Chrome dans vos applications .NET. Avec une documentation complète, de nombreux exemples de code et un support réactif, vous générerez des PDF en minutes, pas en heures.

    Veuillez noterGemBox.Pdf et GemBox.Document sont des marques déposées de leurs propriétaires respectifs. Ce site n'est pas affilié, approuvé ou parrainé par GemBox.Pdf ou GemBox.Document. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à des fins d'information uniquement et reflètent les informations disponibles publiquement au moment de la rédaction.

    Questions Fréquemment Posées

    Comment puis-je convertir HTML en PDF en C# ?

    Vous pouvez utiliser la méthode RenderHtmlAsPdf d'IronPDF pour convertir des chaînes HTML en PDFs. Vous pouvez également convertir des fichiers HTML en PDFs en utilisant RenderHtmlFileAsPdf.

    Puis-je manipuler des fichiers PDF existants avec ces bibliothèques ?

    Oui, IronPDF et GemBox.Pdf peuvent être utilisés pour manipuler des fichiers PDF existants. IronPDF simplifie les tâches courantes comme la fusion, la division et l'ajout de filigranes. GemBox.Pdf offre un contrôle plus granulaire sur les objets PDF, ce qui est utile pour des manipulations complexes.

    Quels sont les avantages d'utiliser IronPDF pour la conversion HTML en PDF ?

    IronPDF offre une qualité supérieure de conversion HTML en PDF avec son moteur de rendu Chrome V8, atteignant une fidélité de +98% par rapport aux navigateurs. Il prend en charge les CSS3 modernes, HTML5, l'exécution de JavaScript, les polices web et les designs réactifs.

    Quelle bibliothèque est la plus rentable pour une petite équipe de développement ?

    Pour une équipe de 3 développeurs ayant besoin de la conversion HTML en PDF, IronPDF coûte 1 499 $ pour la licence Plus, tandis que GemBox coûterait 5 340 $ pour 3 licences GemBox.Pdf et 3 licences GemBox.Document. IronPDF offre un meilleur rapport qualité-prix pour les équipes.

    IronPDF convient-il à la génération de PDF en grand volume ?

    Oui, IronPDF fournit d'excellentes performances avec un temps de rendu HTML en PDF d'environ 125 ms, un support async/await optimisé et une utilisation efficace de la mémoire sous 10 Mo. Il convient parfaitement pour la génération de PDF en ligne de grande envergure.

    Quel type de support est inclus avec IronPDF ?

    IronPDF inclut un support d'ingénierie 24/5 avec un accès direct à l'équipe de développement et des temps de réponse typiques de 24 à 48 heures, ainsi qu'une documentation complète et des exemples de code.

    Puis-je créer des documents conformes à la norme PDF/A avec ces bibliothèques ?

    Oui, IronPDF peut générer des documents conformes à la norme PDF/A avec un simple appel de méthode tel que SaveAsPdfA(), prenant en charge plusieurs versions PDF/A. GemBox.Pdf peut lire des documents PDF/A et maintenir la conformité lors de leur modification.

    Ces bibliothèques sont-elles compatibles avec les frameworks .NET modernes ?

    Oui, les deux bibliothèques prennent en charge les versions modernes de .NET. IronPDF prend en charge .NET Framework 4.6.2+, .NET Core 3.1+ et .NET 5 à 10. GemBox.Pdf prend en charge .NET Framework 3.5+, .NET Standard 2.0 et .NET 6+.

    Quelle bibliothèque est optimisée pour le déploiement sur le cloud ?

    IronPDF est optimisé pour le déploiement sur le cloud avec une assistance spécifique pour Azure, AWS, les conteneurs Docker et les environnements sans serveur. Son approche basée sur HTML s'intègre naturellement aux applications web, ce qui en fait le meilleur choix pour les applications SaaS.

    Existe-t-il une version gratuite disponible pour tester IronPDF ?

    IronPDF propose une option d'évaluation gratuite qui permet un développement et un test illimités sans clé de licence, bien que des filigranes apparaissent sur la sortie. Cela fournit suffisamment de fonctionnalités pour évaluer le produit avant de l'acheter.

    Jacob Mellor, Directeur technique @ Team Iron
    Jacob Mellor
      Discutez maintenant avec l'équipe d'ingénierie
    Directeur technique

    Jacob Mellor est directeur technique chez Iron Software et un ingénieur visionnaire pionnier dans la technologie des PDF en C#. En tant que développeur original derrière la base de code principale d'Iron Software, il a façonné l'architecture du produit de l'entreprise depuis sa création, ...

    Lire la suite

    Articles connexes

    Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit