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

Comment migrer de QuestPDF à IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

Full Comparison

Looking for a detailed feature-by-feature breakdown? See how IronPDF stacks up against QuestPDF on pricing, HTML support, and licensing.

View Full Comparison

La migration de QuestPDF versIronPDFtransforme votre flux de production de PDF, passant d'une API propriétaire fluide en C# à une approche standard basée sur HTML/CSS avec des fonctionnalités complètes de manipulation de PDF. Ce guide fournit un chemin de migration complet, étape par étape, qui vous permet d'exploiter vos compétences web existantes, de réutiliser les modèles HTML et d'obtenir des fonctionnalités que QuestPDF ne peut tout simplement pas fournir.

Pourquoi migrer de QuestPDF à IronPDF

Comprendre QuestPDF

QuestPDF est une API moderne et fluide créée spécifiquement pour générer des PDF de manière programmatique en C#. Contrairement à certains de ses homologues qui offrent une capacité complète de conversion de HTML en PDF, QuestPDF est limité aux fonctionnalités programmatiques de l'API de mise en page. QuestPDF excelle dans les scénarios où les développeurs doivent générer des documents à partir de zéro en utilisant du code C#, sans s'appuyer sur le HTML.

La bibliothèque est gratuite pour les entreprises dont le chiffre d'affaires est inférieur à 1 million de dollars, mais il est nécessaire de prouver ce niveau de chiffre d'affaires, ce qui pourrait constituer une contrainte de conformité pour certaines d'entre elles. Les utilisateurs qui dépassent ce seuil doivent acheter une licence, ce qui doit être pris en compte dans la planification à long terme lors de l'évaluation de QuestPDF en tant que solution potentielle.

Le problème principal : pas de prise en charge HTML

QuestPDF est souvent recommandé pour la conversion de HTML en PDF, mais il ne prend pas du tout en charge le HTML. Bien que fortement promu sur les forums de développeurs, QuestPDF utilise son propre langage de mise en page qui nécessite l'apprentissage d'un DSL entièrement nouveau au lieu d'exploiter les compétences web existantes.

Fonction QuestPDF IronPDF
HTML-à-PDF NON SUPPORTÉ Prise en charge
CSS Styling NON SUPPORTÉ CSS3 complet
Modèles existants Doit être reconstruit à partir de zéro Réutiliser les actifs HTML/CSS
Compatibilité des outils de conception Aucun Tout outil de conception web
Courbe d'apprentissage Nouveau DSL propriétaire Transfert de compétences dans le domaine du web
Aperçu de la mise en page Nécessite un plugin IDE Prévisualisation dans n'importe quel navigateur
Manipulation de PDF Aucun Fusion, division, édition

IronPDF offre un rendu HTML vers PDF en natif qui fait totalement défaut à QuestPDF, éliminant ainsi la nécessité de reconstruire manuellement les documents en code C#. Elle inclut des fonctionnalités complètes de manipulation de PDF (fusion, division, édition, sécurisation) que QuestPDF ne peut pas réaliser.

Le modèle de licence QuestPDF

La "Community License" de QuestPDF n'est gratuite que si votre entreprise a un chiffre d'affaires annuel brut inférieur à 1 million de dollars. Vos clients (et pas seulement vous en tant que développeur) peuvent avoir besoin d'acheter des licences s'ils dépassent les seuils de revenus. Contrairement à une simple licence commerciale par développeur, le modèle de QuestPDF exige la divulgation des revenus et le suivi de la conformité.

IronPDF propose une licence simple : une licence par développeur, pas d'audit des revenus, pas d'exigence de licence client, et des coûts clairs et prévisibles.

Pour les équipes qui prévoient d'adopter .NET 10 et C# 14 d'ici 2025 et 2026,IronPDFoffre une licence transparente sans audit basé sur les revenus et une approche HTML/CSS standard qui tire parti des compétences existantes en matière de développement web.

Avant de commencer

Prérequis

  1. Environnement .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. Accès à NuGet : possibilité d'installer des packages NuGet
  3. Licence IronPDF : Obtenez votre clé de licence sur IronPDF

Modifications du paquet NuGet

# Remove QuestPDF
dotnet remove package QuestPDF

# Add IronPDF
dotnet add package IronPdf
# Remove QuestPDF
dotnet remove package QuestPDF

# Add IronPDF
dotnet add package IronPdf
SHELL

Configuration de la licence

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

Trouver l'utilisation de QuestPDF

# Find all QuestPDF usages in your codebase
grep -r "QuestPDF\|Document.Create\|\.GeneratePdf" --include="*.cs" .
# Find all QuestPDF usages in your codebase
grep -r "QuestPDF\|Document.Create\|\.GeneratePdf" --include="*.cs" .
SHELL

Référence API complète

Modifications de l'espace de nommage

// Before: QuestPDF
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

// After: IronPDF
using IronPdf;
// Before: QuestPDF
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

// After: IronPDF
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Mappages de l'API de base

Concept QuestPDF Équivalent d'IronPDF
Document.Create() new ChromePdfRenderer()
.Page() RenderHtmlAsPdf()
.Text() HTML <p>, <h1>, <span>
.Bold() CSS font-weight: bold
.FontSize(24) CSS font-size: 24px
.Image() HTML <img src="...">
.Table() HTML <table>
.Column() CSS display : flex ; flex-direction : column
.Row() CSS display : flex ; flex-direction : row
PageSizes.A4 RenderingOptions.PaperSize
.Margin() RenderingOptions.Margin*
.GeneratePdf() pdf.SaveAs()
N/A PdfDocument.Merge()
N/A PdfDocument.FromFile()
N/A pdf.SecuritySettings

Exemples de migration de code

Exemple 1 : Création d'un document de base (HTML vers PDF)

Avant (QuestPDF):

// NuGet: Install-Package QuestPDF
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

class Program
{
    static void Main()
    {
        QuestPDF.Settings.License = LicenseType.Community;

        Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                page.Content().Column(column =>
                {
                    column.Item().Text("Hello World").FontSize(20).Bold();
                    column.Item().Text("This is a paragraph of text.");
                });
            });
        }).GeneratePdf("output.pdf");
    }
}
// NuGet: Install-Package QuestPDF
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

class Program
{
    static void Main()
    {
        QuestPDF.Settings.License = LicenseType.Community;

        Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                page.Content().Column(column =>
                {
                    column.Item().Text("Hello World").FontSize(20).Bold();
                    column.Item().Text("This is a paragraph of text.");
                });
            });
        }).GeneratePdf("output.pdf");
    }
}
Imports QuestPDF.Fluent
Imports QuestPDF.Helpers
Imports QuestPDF.Infrastructure

Module Program
    Sub Main()
        QuestPDF.Settings.License = LicenseType.Community

        Document.Create(Sub(container)
                            container.Page(Sub(page)
                                               page.Size(PageSizes.A4)
                                               page.Margin(2, Unit.Centimetre)
                                               page.Content().Column(Sub(column)
                                                                         column.Item().Text("Hello World").FontSize(20).Bold()
                                                                         column.Item().Text("This is a paragraph of text.")
                                                                     End Sub)
                                           End Sub)
                        End Sub).GeneratePdf("output.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a paragraph of text.</p>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a paragraph of text.</p>");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a paragraph of text.</p>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Cet exemple illustre la différence fondamentale de paradigme. QuestPDF nécessite l'apprentissage de son API fluide : Document.Create(), container.Page(), page.Content().Column(), column.Item().Text(), avec un style via un chaînage de méthodes comme .FontSize(20).Bold(). Vous devez également définir le type de licence avec QuestPDF.Settings.License = LicenseType.Community.

IronPDF utilise le HTML standard que tout développeur web connaît : <h1> pour les titres, <p> pour les paragraphes. Aucun langage DSL propriétaire à apprendre. L'approche d'IronPDF offre une syntaxe plus propre et une meilleure intégration avec les applications .NET modernes. Consultez la documentation HTML vers PDF pour des exemples complets.

Exemple 2 : Génération de factures

Avant (QuestPDF):

// NuGet: Install-Package QuestPDF
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

class Program
{
    static void Main()
    {
        QuestPDF.Settings.License = LicenseType.Community;

        Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                page.Content().Column(column =>
                {
                    column.Item().Text("INVOICE").FontSize(24).Bold();
                    column.Item().Text("Invoice #: 12345").FontSize(12);
                    column.Item().PaddingTop(20);
                    column.Item().Text("Customer: John Doe");
                    column.Item().Text("Total: $100.00").Bold();
                });
            });
        }).GeneratePdf("invoice.pdf");
    }
}
// NuGet: Install-Package QuestPDF
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

class Program
{
    static void Main()
    {
        QuestPDF.Settings.License = LicenseType.Community;

        Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                page.Content().Column(column =>
                {
                    column.Item().Text("INVOICE").FontSize(24).Bold();
                    column.Item().Text("Invoice #: 12345").FontSize(12);
                    column.Item().PaddingTop(20);
                    column.Item().Text("Customer: John Doe");
                    column.Item().Text("Total: $100.00").Bold();
                });
            });
        }).GeneratePdf("invoice.pdf");
    }
}
Imports QuestPDF.Fluent
Imports QuestPDF.Helpers
Imports QuestPDF.Infrastructure

Module Program
    Sub Main()
        QuestPDF.Settings.License = LicenseType.Community

        Document.Create(Sub(container)
                            container.Page(Sub(page)
                                               page.Size(PageSizes.A4)
                                               page.Margin(2, Unit.Centimetre)
                                               page.Content().Column(Sub(column)
                                                                         column.Item().Text("INVOICE").FontSize(24).Bold()
                                                                         column.Item().Text("Invoice #: 12345").FontSize(12)
                                                                         column.Item().PaddingTop(20)
                                                                         column.Item().Text("Customer: John Doe")
                                                                         column.Item().Text("Total: $100.00").Bold()
                                                                     End Sub)
                                           End Sub)
                        End Sub).GeneratePdf("invoice.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var htmlContent = @"
            <h1>INVOICE</h1>
            <p>Invoice #: 12345</p>
            <br/>
            <p>Customer: John Doe</p>
            <p><strong>Total: $100.00</strong></p>
        ";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("invoice.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var htmlContent = @"
            <h1>INVOICE</h1>
            <p>Invoice #: 12345</p>
            <br/>
            <p>Customer: John Doe</p>
            <p><strong>Total: $100.00</strong></p>
        ";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("invoice.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim htmlContent As String = "
            <h1>INVOICE</h1>
            <p>Invoice #: 12345</p>
            <br/>
            <p>Customer: John Doe</p>
            <p><strong>Total: $100.00</strong></p>
        "

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("invoice.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

QuestPDF utilise .Column() et .Item() pour la mise en page, avec .PaddingTop(20) pour l'espacement.IronPDFutilise le HTML standard : <h1> pour le titre, <p> pour les paragraphes, <br/> pour l'espacement et <strong> pour le texte en gras.

Le véritable avantage : avec IronPDF, les concepteurs peuvent créer et modifier des modèles HTML de manière autonome. Avec QuestPDF, chaque changement de conception nécessite qu'un développeur C# modifie le code. Pour en savoir plus, consultez nos tutoriels.

Exemple 3 : En-têtes et pieds de page avec numéros de page

Avant (QuestPDF):

// NuGet: Install-Package QuestPDF
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

class Program
{
    static void Main()
    {
        QuestPDF.Settings.License = LicenseType.Community;

        Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);

                page.Header().Text("Document Header").FontSize(14).Bold();

                page.Content().Text("Main content of the document.");

                page.Footer().AlignCenter().Text(text =>
                {
                    text.Span("Page ");
                    text.CurrentPageNumber();
                });
            });
        }).GeneratePdf("document.pdf");
    }
}
// NuGet: Install-Package QuestPDF
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

class Program
{
    static void Main()
    {
        QuestPDF.Settings.License = LicenseType.Community;

        Document.Create(container =>
        {
            container.Page(page =>
            {
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);

                page.Header().Text("Document Header").FontSize(14).Bold();

                page.Content().Text("Main content of the document.");

                page.Footer().AlignCenter().Text(text =>
                {
                    text.Span("Page ");
                    text.CurrentPageNumber();
                });
            });
        }).GeneratePdf("document.pdf");
    }
}
Imports QuestPDF.Fluent
Imports QuestPDF.Helpers
Imports QuestPDF.Infrastructure

Module Program
    Sub Main()
        QuestPDF.Settings.License = LicenseType.Community

        Document.Create(Sub(container)
                            container.Page(Sub(page)
                                               page.Size(PageSizes.A4)
                                               page.Margin(2, Unit.Centimetre)

                                               page.Header().Text("Document Header").FontSize(14).Bold()

                                               page.Content().Text("Main content of the document.")

                                               page.Footer().AlignCenter().Text(Sub(text)
                                                                                    text.Span("Page ")
                                                                                    text.CurrentPageNumber()
                                                                                End Sub)
                                           End Sub)
                        End Sub).GeneratePdf("document.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var htmlContent = "<p>Main content of the document.</p>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        pdf.Header = new TextHeaderFooter()
        {
            CenterText = "Document Header",
            FontSize = 14
        };

        pdf.Footer = new TextHeaderFooter()
        {
            CenterText = "Page {page}"
        };

        pdf.SaveAs("document.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var htmlContent = "<p>Main content of the document.</p>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        pdf.Header = new TextHeaderFooter()
        {
            CenterText = "Document Header",
            FontSize = 14
        };

        pdf.Footer = new TextHeaderFooter()
        {
            CenterText = "Page {page}"
        };

        pdf.SaveAs("document.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim htmlContent As String = "<p>Main content of the document.</p>"

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

        pdf.Header = New TextHeaderFooter() With {
            .CenterText = "Document Header",
            .FontSize = 14
        }

        pdf.Footer = New TextHeaderFooter() With {
            .CenterText = "Page {page}"
        }

        pdf.SaveAs("document.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

QuestPDF utilise page.Header() et page.Footer() avec des méthodes fluides comme .AlignCenter() et .CurrentPageNumber().IronPDFutilise des objets TextHeaderFooter avec des propriétés comme CenterText et FontSize. Le marqueur {page} insère automatiquement le numéro de page actuel.

Notes de migration essentielles

Le changement de paradigme

Le changement fondamental consiste à passer d'un DSL C# propriétaire à un langage HTML/CSS standard :

// QuestPDF: Proprietary fluent API
container.Page(page =>
{
    page.Content().Column(column =>
    {
        column.Item().Text("Invoice").Bold().FontSize(24);
        column.Item().Row(row =>
        {
            row.RelativeItem().Text("Customer:");
            row.RelativeItem().Text("Acme Corp");
        });
    });
});

// IronPDF: Standard HTML/CSS
var html = @"
<div style='font-family: Arial; padding: 40px;'>
    <h1 style='font-weight: bold; font-size: 24px;'>Invoice</h1>
    <div style='display: flex; justify-content: space-between;'>
        <span>Customer:</span>
        <span>Acme Corp</span>
    </div>
</div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// QuestPDF: Proprietary fluent API
container.Page(page =>
{
    page.Content().Column(column =>
    {
        column.Item().Text("Invoice").Bold().FontSize(24);
        column.Item().Row(row =>
        {
            row.RelativeItem().Text("Customer:");
            row.RelativeItem().Text("Acme Corp");
        });
    });
});

// IronPDF: Standard HTML/CSS
var html = @"
<div style='font-family: Arial; padding: 40px;'>
    <h1 style='font-weight: bold; font-size: 24px;'>Invoice</h1>
    <div style='display: flex; justify-content: space-between;'>
        <span>Customer:</span>
        <span>Acme Corp</span>
    </div>
</div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
' QuestPDF: Proprietary fluent API
container.Page(Sub(page)
    page.Content().Column(Sub(column)
        column.Item().Text("Invoice").Bold().FontSize(24)
        column.Item().Row(Sub(row)
            row.RelativeItem().Text("Customer:")
            row.RelativeItem().Text("Acme Corp")
        End Sub)
    End Sub)
End Sub)

' IronPDF: Standard HTML/CSS
Dim html As String = "
<div style='font-family: Arial; padding: 40px;'>
    <h1 style='font-weight: bold; font-size: 24px;'>Invoice</h1>
    <div style='display: flex; justify-content: space-between;'>
        <span>Customer:</span>
        <span>Acme Corp</span>
    </div>
</div>"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Conversions de modèles de mise en page

Modèle QuestPDF Équivalent HTML/CSS
.Column() display : flex ; flex-direction : column
.Row() display : flex ; flex-direction : row
.RelativeItem() flex: 1
.Table() <table> élément
.PaddingTop(20) padding-top: 20px ou <br/>
.AlignCenter() text-align: center
.FontSize(24) font-size: 24px
.Bold() font-weight: bold ou <strong>

Conversion des paramètres de page

// QuestPDF
page.Size(PageSizes.A4);
page.Margin(2, Unit.Centimetre);

// IronPDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;    // mm (2cm = 20mm)
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
// QuestPDF
page.Size(PageSizes.A4);
page.Margin(2, Unit.Centimetre);

// IronPDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;    // mm (2cm = 20mm)
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
' QuestPDF
page.Size(PageSizes.A4)
page.Margin(2, Unit.Centimetre)

' IronPDF
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20 ' mm (2cm = 20mm)
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20
$vbLabelText   $csharpLabel

Nouvelles capacités après la migration

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

Fusion de fichiers PDF

var cover = renderer.RenderHtmlAsPdf("<h1>Cover</h1>");
var content = renderer.RenderHtmlAsPdf(reportHtml);
var existing = PdfDocument.FromFile("appendix.pdf");

var merged = PdfDocument.Merge(cover, content, existing);
merged.SaveAs("complete.pdf");
var cover = renderer.RenderHtmlAsPdf("<h1>Cover</h1>");
var content = renderer.RenderHtmlAsPdf(reportHtml);
var existing = PdfDocument.FromFile("appendix.pdf");

var merged = PdfDocument.Merge(cover, content, existing);
merged.SaveAs("complete.pdf");
Dim cover = renderer.RenderHtmlAsPdf("<h1>Cover</h1>")
Dim content = renderer.RenderHtmlAsPdf(reportHtml)
Dim existing = PdfDocument.FromFile("appendix.pdf")

Dim merged = PdfDocument.Merge(cover, content, existing)
merged.SaveAs("complete.pdf")
$vbLabelText   $csharpLabel

Sécurité des PDF

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "reader";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SaveAs("protected.pdf");
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "reader";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SaveAs("protected.pdf");
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "reader"
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights
pdf.SaveAs("protected.pdf")
$vbLabelText   $csharpLabel

URL en PDF

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;

var pdf = renderer.RenderUrlAsPdf("https://example.com/report");
pdf.SaveAs("webpage.pdf");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;

var pdf = renderer.RenderUrlAsPdf("https://example.com/report");
pdf.SaveAs("webpage.pdf");
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True

Dim pdf = renderer.RenderUrlAsPdf("https://example.com/report")
pdf.SaveAs("webpage.pdf")
$vbLabelText   $csharpLabel

Chargez et modifiez des PDF existants

var pdf = PdfDocument.FromFile("existing.pdf");
// Modify, merge, add security, etc.
pdf.SaveAs("modified.pdf");
var pdf = PdfDocument.FromFile("existing.pdf");
// Modify, merge, add security, etc.
pdf.SaveAs("modified.pdf");
Dim pdf = PdfDocument.FromFile("existing.pdf")
' Modify, merge, add security, etc.
pdf.SaveAs("modified.pdf")
$vbLabelText   $csharpLabel

Résumé de la comparaison des fonctionnalités

Fonction QuestPDF IronPDF
HTML-à-PDF Non pris en charge Caractéristiques principales
Courbe d'apprentissage DSL propriétaire Compétences web standard
Aperçu du modèle Plugin requis Tout navigateur
Collaboration en matière de conception Développeurs uniquement Concepteurs + développeurs
Actifs existants Doit reconstruire Réutiliser HTML/CSS
Manipulation de PDF Non pris en charge Prise en charge
Sécurité/Signature Non pris en charge Prise en charge
Modèle de licence Basé sur les revenus Par développeur
Impact sur le client Besoin éventuel de licences Aucun
Bootstrap/Tailwind Non pris en charge Prise en charge
URL vers PDF Non pris en charge Prise en charge

Liste de contrôle de la migration

Pré-migration

  • Identifier tous les modèles de documents QuestPDF (Document.Create, .GeneratePdf)
  • Documenter les modèles DSL utilisés (.Column(), .Row(), .Table(), .Text())
  • Associer les méthodes de style à leurs équivalents CSS
  • Obtenez votre clé de licenceIronPDFsur IronPDF

Modifications du paquet

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

Modifications du code

  • Mettre à jour les importations d'espace de noms
  • Supprimer QuestPDF.Settings.License = LicenseType.Community
  • Convertir le modèle Document.Create() en ChromePdfRenderer + HTML
  • Remplacez .Column() / .Row() par CSS Flexbox
  • Remplacez .Table() par les éléments HTML <table>
  • Convertir .Text().Bold().FontSize(24) en <h1 style='...'>
  • Remplacez page.Header() / page.Footer() par TextHeaderFooter
  • Remplacez .CurrentPageNumber() par {page} espace réservé
  • Convertir .GeneratePdf() en pdf.SaveAs()
  • Ajouter l'initialisation de la licence au démarrage de l'application

Après la migration

  • Comparaison visuelle des fichiers PDF générés
  • Vérifier que les documents multipages comportent des sauts de page corrects.
  • Ajouter de nouvelles fonctionnalités (sécurité, fusion, conversion d'URL en PDF) selon les besoins
Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

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

Lire la suite

Articles connexes

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

Équipe de soutien Iron

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