Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. .NET Core Créer un PDF
UTILISATION DE IRONPDF

Comment créer des fichiers PDF dans .NET Core avec IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

IronPDF crée des fichiers PDF dans les applications .NET Core grâce à la conversion HTML vers PDF via son moteur de rendu Chrome, prenant en charge CSS3, JavaScript, les images et les mises en page complexes avec un code C# simple.

La création de documents PDF par programmation est une exigence courante dans les applications web modernes. Que vous créiez des factures, des rapports ou tout autre système basé sur des documents, il est essentiel de savoir comment créer efficacement des fichiers PDF avec ASP.NET Core . Ce tutoriel explore les meilleures méthodes pour créer des fichiers PDF dans .NET Core en using IronPDF , une bibliothèque performante qui simplifie la génération de PDF. Pour obtenir tous les détails techniques, veuillez vous référer à la documentation officielle .

IronPDF permet aux développeurs .NET Core de créer des fichiers PDF à l'aide de code HTML et CSS simple, éliminant ainsi les opérations de dessin PDF manuelles complexes grâce à son API intuitive et son moteur de rendu. La bibliothèque est compatible avec divers environnements de déploiement, notamment Windows, Linux, macOS et les plateformes cloud telles qu'Azure et AWS Lambda . Le moteur de rendu Chrome de la bibliothèque garantit une conversion HTML vers PDF précise au pixel près, avec une prise en charge complète des types de médias d'écran et d'impression CSS.

Comment débuter la génération de PDF dans .NET Core?

IronPDF est une bibliothèque PDF .NET Core complète qui transforme la création complexe de PDF en opérations simples. Contrairement aux approches traditionnelles qui nécessitent de dessiner les éléments manuellement, IronPDF utilise le balisage HTML et le CSS pour générer des fichiers PDF qui correspondent exactement à vos exigences de conception. La bibliothèque utilise un moteur de rendu Chrome en interne, garantissant une conversion HTML vers PDF parfaite au pixel près. Cette approche la rend idéale pour créer de nouveaux PDF ainsi que pour convertir du contenu existant au format PDF.

Lors de l'évaluation des solutions de génération de PDF for .NET Core, les développeurs comparent souvent plusieurs options. IronPDF se distingue de ses concurrents tels que iText , Aspose et Syncfusion pour plusieurs raisons :

  • Qualité de rendu supérieure : le moteur basé sur Chrome garantit une fidélité HTML/CSS précise.
  • API simplifiée : Créez des PDF en utilisant la connaissance du HTML plutôt que des primitives PDF complexes.
  • Compatibilité multiplateforme : binaires natifs pour Windows, Linux, macOS et les plateformes cloud
  • Fonctionnalités complètes : De la création de base à la manipulation avancée et à la sécurité

Comment installer IronPDF?

Pour commencer à créer des fichiers PDF dans votre projet .NET Core , installez le package NuGet IronPDF . Utilisez la console du gestionnaire de packages :

Install-Package IronPdf
Install-Package IronPdf
SHELL

Ou l'interface de ligne de commande .NET :

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Cette installation vous donne un accès immédiat aux fonctionnalités de génération de PDF pour vos applications web. Pour des scénarios d'installation plus avancés, consultez la documentation des packages NuGet ou explorez les options de déploiement Docker .

Comment créer son premier document PDF ?

L'exemple suivant illustre la génération de fichiers PDF avec un contenu formaté à l'aide des fonctionnalités de conversion de chaînes HTML en PDF d'IronPDF. Cette méthode est idéale pour créer des PDF à partir de contenu dynamique ou lorsque vous devez exporter du HTML au format PDF :

using IronPdf;

// Create a new ChromePdfRenderer
var renderer = new ChromePdfRenderer();

// Define HTML content with styling
var html = @"
    <html>
        <body style='font-family: Arial; margin: 40px;'>
            <h1>Hello World PDF Document</h1>
            <p>This is your first PDF file created with IronPDF!</p>
        </body>
    </html>";

// Generate PDF from HTML
var pdf = renderer.RenderHtmlAsPdf(html);

// Save the PDF document
pdf.SaveAs("output.pdf");
using IronPdf;

// Create a new ChromePdfRenderer
var renderer = new ChromePdfRenderer();

// Define HTML content with styling
var html = @"
    <html>
        <body style='font-family: Arial; margin: 40px;'>
            <h1>Hello World PDF Document</h1>
            <p>This is your first PDF file created with IronPDF!</p>
        </body>
    </html>";

// Generate PDF from HTML
var pdf = renderer.RenderHtmlAsPdf(html);

// Save the PDF document
pdf.SaveAs("output.pdf");
Imports IronPdf

' Create a new ChromePdfRenderer
Dim renderer As New ChromePdfRenderer()

' Define HTML content with styling
Dim html As String = "
    <html>
        <body style='font-family: Arial; margin: 40px;'>
            <h1>Hello World PDF Document</h1>
            <p>This is your first PDF file created with IronPDF!</p>
        </body>
    </html>"

' Generate PDF from HTML
Dim pdf = renderer.RenderHtmlAsPdf(html)

' Save the PDF document
pdf.SaveAs("output.pdf")
$vbLabelText   $csharpLabel

Ce code crée un nouveau document PDF en interprétant le contenu HTML. Le ChromePdfRenderer gère la conversion, garantissant ainsi que vos documents PDF conservent une mise en forme cohérente. Vous pouvez également enregistrer les fichiers PDF dans des flux de mémoire pour les applications Web qui renvoient le fichier directement plutôt que de l'écrire sur le disque.

Comprendre les composants essentiels vous aide à utiliser IronPDF efficacement :

  • ChromePdfRenderer : Le moteur de rendu principal qui convertit le HTML en PDF
  • PdfDocument : Représente le document PDF à manipuler
  • RenderingOptions : Contrôle la mise en page, les marges, les en-têtes et autres paramètres
  • SecuritySettings : Gère les mots de passe, les autorisations et le chiffrement

L'utilisation du HTML pour la création de PDF offre des avantages considérables par rapport aux API PDF traditionnelles. Les développeurs peuvent exploiter leurs compétences HTML/CSS existantes, les frameworks CSS s'appliquent naturellement, le rendu JavaScript est effectué avant la conversion et les requêtes média s'adaptent aux dimensions du PDF. La mise à jour du contenu PDF ne nécessite rien de plus que la modification d'un modèle HTML.

IronPDF ChromePdfRenderer creating Hello World PDF document with Arial font styling in .NET Core

Le PDF généré démontre la capacité d'IronPDF à convertir du HTML avec style CSS en un document PDF Professional .

Comment convertir du HTML en PDF avec des mises en page avancées ?

IronPDF excelle à convertir des pages web complexes et du contenu HTML en fichiers PDF professionnels. La fonction de conversion HTML vers PDF prend en charge les technologies CSS3 modernes, JavaScript et les designs responsifs. La bibliothèque gère les polices web, les mises en page Bootstrap et Flexbox, et même les frameworks JavaScript . Le code suivant montre comment créer un document PDF avec des tableaux, des images et des éléments stylisés, ainsi qu'un contrôle précis de la mise en page :

using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure rendering options
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;

// Enable JavaScript for dynamic content
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);

// Set viewport and CSS media type
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

var html = @"
    <html>
    <head>
        <style>
            table { width: 100%; border-collapse: collapse; }
            th, td { padding: 10px; border: 1px solid #ddd; }
            th { background-color: #f2f2f2; }
        </style>
    </head>
    <body>
        <h2>Sales Report</h2>
        <table>
            <tr><th>Product</th><th>Quantity</th><th>Total</th></tr>
            <tr><td>Software License</td><td>10</td><td>$500</td></tr>
        </table>
    </body>
    </html>";

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure rendering options
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;

// Enable JavaScript for dynamic content
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);

// Set viewport and CSS media type
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

var html = @"
    <html>
    <head>
        <style>
            table { width: 100%; border-collapse: collapse; }
            th, td { padding: 10px; border: 1px solid #ddd; }
            th { background-color: #f2f2f2; }
        </style>
    </head>
    <body>
        <h2>Sales Report</h2>
        <table>
            <tr><th>Product</th><th>Quantity</th><th>Total</th></tr>
            <tr><td>Software License</td><td>10</td><td>$500</td></tr>
        </table>
    </body>
    </html>";

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
Imports IronPdf

Dim renderer = New ChromePdfRenderer()

' Configure rendering options
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25

' Enable JavaScript for dynamic content
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1000)

' Set viewport and CSS media type
renderer.RenderingOptions.ViewPortWidth = 1024
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

Dim html As String = "
    <html>
    <head>
        <style>
            table { width: 100%; border-collapse: collapse; }
            th, td { padding: 10px; border: 1px solid #ddd; }
            th { background-color: #f2f2f2; }
        </style>
    </head>
    <body>
        <h2>Sales Report</h2>
        <table>
            <tr><th>Product</th><th>Quantity</th><th>Total</th></tr>
            <tr><td>Software License</td><td>10</td><td>$500</td></tr>
        </table>
    </body>
    </html>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

Le moteur Chrome d'IronPDF prend en charge de nombreuses fonctionnalités CSS : Flexbox, CSS Grid, flottants, positionnement, transformations CSS3, transitions, animations, polices web, polices variables, requêtes média spécifiques à l'impression et sélecteurs de pseudo-éléments. Vous pouvez également définir des marges et des formats de papier personnalisés, et gérer les polices pour la prise en charge des langues internationales.

PDF viewer displaying a professionally formatted Sales Report with a table showing Software License product data including quantity (10) and total ($500), demonstrating IronPDF's advanced table formatting and CSS styling capabilities in .NET Core applications

Advanced IronPDF table rendering with CSS styling showing sales report data in formatted PDF

La mise en forme avancée des tableaux illustre les capacités de rendu CSS d'IronPDF pour les documents commerciaux Professional .

Comment intégrer la génération de PDF dans ASP.NET Core?

L'intégration de la génération de PDF dans ASP.NET Core MVC est simple. IronPDF s'intègre aux applicationsASP.NET Core MVC , Razor Pages et Blazor Server. Voici une implémentation complète montrant une action de contrôleur et un point de terminaison d'API minimal fonctionnant côte à côte :

using Microsoft.AspNetCore.Mvc;
using IronPdf;

// --- MVC Controller approach ---
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();

// Minimal API endpoint
app.MapGet("/api/pdf/{id}", async (int id) =>
{
    var renderer = new ChromePdfRenderer();
    var html = $"<h1>Invoice #{id}</h1><p>Thank you for your purchase!</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
});

app.Run();

// --- MVC Controller ---
public class DocumentController : Controller
{
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<h1>Invoice</h1><p>Thank you for your purchase!</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        return File(pdf.BinaryData, "application/pdf", "document.pdf");
    }
}
using Microsoft.AspNetCore.Mvc;
using IronPdf;

// --- MVC Controller approach ---
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();

// Minimal API endpoint
app.MapGet("/api/pdf/{id}", async (int id) =>
{
    var renderer = new ChromePdfRenderer();
    var html = $"<h1>Invoice #{id}</h1><p>Thank you for your purchase!</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
});

app.Run();

// --- MVC Controller ---
public class DocumentController : Controller
{
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<h1>Invoice</h1><p>Thank you for your purchase!</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        return File(pdf.BinaryData, "application/pdf", "document.pdf");
    }
}
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf

' --- MVC Controller approach ---
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()
Dim app = builder.Build()

' Minimal API endpoint
app.MapGet("/api/pdf/{id}", Async Function(id As Integer)
                                  Dim renderer = New ChromePdfRenderer()
                                  Dim html = $"<h1>Invoice #{id}</h1><p>Thank you for your purchase!</p>"
                                  Dim pdf = renderer.RenderHtmlAsPdf(html)
                                  Return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf")
                              End Function)

app.Run()

' --- MVC Controller ---
Public Class DocumentController
    Inherits Controller

    Public Function GeneratePdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<h1>Invoice</h1><p>Thank you for your purchase!</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        Return File(pdf.BinaryData, "application/pdf", "document.pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

La méthode du contrôleur génère un document PDF et le renvoie sous forme de fichier téléchargeable, idéal pour le traitement côté serveur. Pour des scénarios plus complexes, envisagez d'utiliser la conversion d'URL en PDF pour convertir directement les pages Web en direct en PDF.

Les applications Enterprise nécessitent une génération de PDF fiable et compatible avec leur infrastructure existante. IronPDF gère des milliers de requêtes PDF simultanées, génère des documents sensibles côté serveur, fonctionne avec l'injection de dépendances et les intergiciels, et se déploie sur Service d'application Azure ou AWS. Suivez ces instructions pour la génération de PDF prêts pour la production : utilisez l'injection de dépendances en enregistrant les services IronPDF dans votre code de démarrage, implémentez la mise en cache des PDF fréquemment générés, gérez les erreurs avec élégance grâce à des options de repli et sécurisez les données sensibles à l'aide de mots de passe et d'autorisations PDF.

ASP.NET Core controller generating invoice PDF with IronPDF showing thank you message

Le PDF généré par le contrôleur démontre une intégration fluide avec les applications web ASP.NET Core .

Comment ajouter des en-têtes, des pieds de page et fusionner des documents ?

IronPDF prend en charge de nombreuses fonctionnalités avancées pour la création de PDF. Vous pouvez ajouter des en-têtes et des pieds de page , insérer des numéros de page et fusionner plusieurs fichiers PDF . La bibliothèque prend également en charge les filigranes , les signatures numériques , les signets , l'ajout de tampons sur du texte et des images , et la création d'une table des matières :

using IronPdf;

var renderer = new ChromePdfRenderer();

// Add text header and footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "Company Report",
    DrawDividerLine = true
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "Page {page} of {total-pages}",
    DrawDividerLine = true
};

// Add HTML-based branded header
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: center'><img src='logo.png' /></div>",
    Height = 30
};

renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;

var html = "<h1>Annual Report</h1><p>Content goes here...</p>";
var mainPdf = renderer.RenderHtmlAsPdf(html);

// Merge multiple PDFs
var coverPdf = renderer.RenderHtmlAsPdf("<p>Cover Page</p>");
var merged = PdfDocument.Merge(coverPdf, mainPdf);

// Apply security
merged.SecuritySettings.SetPassword("user-password");
merged.SecuritySettings.AllowUserPrinting = true;
merged.SecuritySettings.AllowUserCopyPasteContent = false;

merged.SaveAs("report-with-header.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

// Add text header and footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "Company Report",
    DrawDividerLine = true
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "Page {page} of {total-pages}",
    DrawDividerLine = true
};

// Add HTML-based branded header
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: center'><img src='logo.png' /></div>",
    Height = 30
};

renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;

var html = "<h1>Annual Report</h1><p>Content goes here...</p>";
var mainPdf = renderer.RenderHtmlAsPdf(html);

// Merge multiple PDFs
var coverPdf = renderer.RenderHtmlAsPdf("<p>Cover Page</p>");
var merged = PdfDocument.Merge(coverPdf, mainPdf);

// Apply security
merged.SecuritySettings.SetPassword("user-password");
merged.SecuritySettings.AllowUserPrinting = true;
merged.SecuritySettings.AllowUserCopyPasteContent = false;

merged.SaveAs("report-with-header.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Add text header and footer
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .CenterText = "Company Report",
    .DrawDividerLine = True
}
renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
    .CenterText = "Page {page} of {total-pages}",
    .DrawDividerLine = True
}

' Add HTML-based branded header
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align: center'><img src='logo.png' /></div>",
    .Height = 30
}

renderer.RenderingOptions.MarginTop = 50
renderer.RenderingOptions.MarginBottom = 50

Dim html As String = "<h1>Annual Report</h1><p>Content goes here...</p>"
Dim mainPdf As PdfDocument = renderer.RenderHtmlAsPdf(html)

' Merge multiple PDFs
Dim coverPdf As PdfDocument = renderer.RenderHtmlAsPdf("<p>Cover Page</p>")
Dim merged As PdfDocument = PdfDocument.Merge(coverPdf, mainPdf)

' Apply security
merged.SecuritySettings.SetPassword("user-password")
merged.SecuritySettings.AllowUserPrinting = True
merged.SecuritySettings.AllowUserCopyPasteContent = False

merged.SaveAs("report-with-header.pdf")
$vbLabelText   $csharpLabel

Ces exemples illustrent comment apporter une touche Professional et combiner plusieurs fichiers en un seul document. Les principales fonctionnalités d'amélioration des PDF Professional incluent : en-têtes/pieds de page pour une cohérence de marque, numéros de page pour la navigation multipage, filigranes pour la sécurité et l'identification des brouillons, signets pour les documents longs et génération automatique de la table des matières. Vous pouvez également explorer l'orientation et la rotation des pages, la compression PDF ou les documents conformes à la norme PDF/A pour l'archivage à long terme.

Document PDF présentant un modèle de rapport annuel Professional avec l'en-tête

Professional PDF with custom headers and footers created using IronPDF TextHeaderFooter

Des en-têtes et pieds de page Professional améliorent la présentation et la navigation des documents.

Comment créer des formulaires PDF interactifs ?

IronPDF permet de créer des formulaires PDF interactifs avec différents champs de saisie : zones de texte, cases à cocher, boutons radio et listes déroulantes. Vous pouvez également remplir et modifier des formulaires PDF existants par programmation. La bibliothèque prend en charge l'extraction des données de formulaires et peut aplatir les formulaires pour les rendre non modifiables :

using IronPdf;
using System.IO;

// Create a form from HTML
var html = @"
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .form-container { width: 400px; padding: 20px; border: 1px solid #ccc; border-radius: 8px; }
        .form-group { margin-bottom: 15px; }
        label { display: block; margin-bottom: 5px; font-weight: bold; color: #333; }
        input[type='text'], textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 4px; box-sizing: border-box; }
        textarea { height: 100px; resize: vertical; }
    </style>
</head>
<body>
    <div class='form-container'>
        <h2>Document Generation Test Form</h2>
        <form>
            <div class='form-group'>
                <label for='fullName'>Full Name:</label>
                <input type='text' id='fullName' name='fullName'>
            </div>
            <div class='form-group'>
                <label for='comments'>Comments/Feedback:</label>
                <textarea id='comments' name='comments' placeholder='Type your feedback here...'></textarea>
            </div>
            <div class='form-group'>
                <input type='checkbox' id='agree' name='agree'>
                <label for='agree'>I agree to the terms and conditions.</label>
            </div>
            <button style='padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer;'>
                Submit
            </button>
        </form>
    </div>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("form.pdf");

// Read back and process form data
var loadedPdf = new PdfDocument("form.pdf");
var fullName = loadedPdf.Form.FindFormField("fullName").Value;
Console.WriteLine($"Full Name: {fullName}");

// Flatten form to prevent further editing
loadedPdf.Form.Flatten();
loadedPdf.SaveAs("processed-form.pdf");
using IronPdf;
using System.IO;

// Create a form from HTML
var html = @"
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .form-container { width: 400px; padding: 20px; border: 1px solid #ccc; border-radius: 8px; }
        .form-group { margin-bottom: 15px; }
        label { display: block; margin-bottom: 5px; font-weight: bold; color: #333; }
        input[type='text'], textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 4px; box-sizing: border-box; }
        textarea { height: 100px; resize: vertical; }
    </style>
</head>
<body>
    <div class='form-container'>
        <h2>Document Generation Test Form</h2>
        <form>
            <div class='form-group'>
                <label for='fullName'>Full Name:</label>
                <input type='text' id='fullName' name='fullName'>
            </div>
            <div class='form-group'>
                <label for='comments'>Comments/Feedback:</label>
                <textarea id='comments' name='comments' placeholder='Type your feedback here...'></textarea>
            </div>
            <div class='form-group'>
                <input type='checkbox' id='agree' name='agree'>
                <label for='agree'>I agree to the terms and conditions.</label>
            </div>
            <button style='padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer;'>
                Submit
            </button>
        </form>
    </div>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("form.pdf");

// Read back and process form data
var loadedPdf = new PdfDocument("form.pdf");
var fullName = loadedPdf.Form.FindFormField("fullName").Value;
Console.WriteLine($"Full Name: {fullName}");

// Flatten form to prevent further editing
loadedPdf.Form.Flatten();
loadedPdf.SaveAs("processed-form.pdf");
Imports IronPdf
Imports System.IO

' Create a form from HTML
Dim html As String = "
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .form-container { width: 400px; padding: 20px; border: 1px solid #ccc; border-radius: 8px; }
        .form-group { margin-bottom: 15px; }
        label { display: block; margin-bottom: 5px; font-weight: bold; color: #333; }
        input[type='text'], textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 4px; box-sizing: border-box; }
        textarea { height: 100px; resize: vertical; }
    </style>
</head>
<body>
    <div class='form-container'>
        <h2>Document Generation Test Form</h2>
        <form>
            <div class='form-group'>
                <label for='fullName'>Full Name:</label>
                <input type='text' id='fullName' name='fullName'>
            </div>
            <div class='form-group'>
                <label for='comments'>Comments/Feedback:</label>
                <textarea id='comments' name='comments' placeholder='Type your feedback here...'></textarea>
            </div>
            <div class='form-group'>
                <input type='checkbox' id='agree' name='agree'>
                <label for='agree'>I agree to the terms and conditions.</label>
            </div>
            <button style='padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer;'>
                Submit
            </button>
        </form>
    </div>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = True
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("form.pdf")

' Read back and process form data
Dim loadedPdf As New PdfDocument("form.pdf")
Dim fullName As String = loadedPdf.Form.FindFormField("fullName").Value
Console.WriteLine($"Full Name: {fullName}")

' Flatten form to prevent further editing
loadedPdf.Form.Flatten()
loadedPdf.SaveAs("processed-form.pdf")
$vbLabelText   $csharpLabel

Cela crée un PDF interactif avec des champs de formulaire que les utilisateurs peuvent remplir, parfait pour les applications nécessitant une saisie utilisateur. Les PDF interactifs répondent à des besoins essentiels des entreprises : collecte d'informations sans formulaires web, possibilité d'utilisation hors ligne pour les utilisateurs sans accès à Internet, conformité légale grâce à des formulaires signés et interfaces PDF familières qui réduisent le temps de formation.

La manipulation sécurisée des formulaires requiert une attention particulière. Validez et nettoyez systématiquement toutes les données des formulaires, limitez la modification des champs de formulaire à l'aide de contrôles d'accès, enregistrez toutes les soumissions de formulaires pour les pistes d'audit, protégez les données sensibles des formulaires par chiffrement et vérifiez l'authenticité des formulaires à l'aide de signatures numériques.

IronPDF interactive form with text fields, checkbox, and button demonstrating form creation

Les formulaires interactifs permettent la collecte de données directement dans les documents PDF.

Comment gérez-vous les performances et la gestion des erreurs en production ?

Lors de la génération de fichiers PDF en production, mettez en œuvre une gestion des erreurs appropriée et tenez compte de l'optimisation des performances. IronPDF offre une prise en charge asynchrone et multithread pour les scénarios à volume élevé. Vous devriez également implémenter une journalisation personnalisée pour le débogage et la surveillance. La création d'instances de rendu engendre des frais généraux, il est donc essentiel de les réutiliser efficacement. L'exemple suivant combine la gestion des erreurs de production et la réutilisation du moteur de rendu :

using IronPdf;
using Microsoft.Extensions.Logging;

// Register a reusable renderer as a singleton in your DI container
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(500);

// Resilient generation with retry and exponential backoff
async Task<byte[]> GenerateWithRetry(string html, ILogger logger, int maxRetries = 3)
{
    for (int attempt = 1; attempt <= maxRetries; attempt++)
    {
        try
        {
            renderer.RenderingOptions.Timeout = 60;
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
            pdf.SecuritySettings.MakePdfDocumentReadOnly();
            pdf.SecuritySettings.SetPassword("userPassword123");
            logger.LogInformation("PDF generated successfully on attempt {Attempt}", attempt);
            return pdf.BinaryData;
        }
        catch (Exception ex) when (attempt < maxRetries)
        {
            logger.LogWarning(ex, "PDF generation failed, attempt {Attempt} of {MaxRetries}", attempt, maxRetries);
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
    }
    throw new InvalidOperationException("Failed to generate PDF after retries");
}
using IronPdf;
using Microsoft.Extensions.Logging;

// Register a reusable renderer as a singleton in your DI container
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(500);

// Resilient generation with retry and exponential backoff
async Task<byte[]> GenerateWithRetry(string html, ILogger logger, int maxRetries = 3)
{
    for (int attempt = 1; attempt <= maxRetries; attempt++)
    {
        try
        {
            renderer.RenderingOptions.Timeout = 60;
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
            pdf.SecuritySettings.MakePdfDocumentReadOnly();
            pdf.SecuritySettings.SetPassword("userPassword123");
            logger.LogInformation("PDF generated successfully on attempt {Attempt}", attempt);
            return pdf.BinaryData;
        }
        catch (Exception ex) when (attempt < maxRetries)
        {
            logger.LogWarning(ex, "PDF generation failed, attempt {Attempt} of {MaxRetries}", attempt, maxRetries);
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
    }
    throw new InvalidOperationException("Failed to generate PDF after retries");
}
Imports IronPdf
Imports Microsoft.Extensions.Logging
Imports System.Threading.Tasks

' Register a reusable renderer as a singleton in your DI container
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(500)

' Resilient generation with retry and exponential backoff
Async Function GenerateWithRetry(html As String, logger As ILogger, Optional maxRetries As Integer = 3) As Task(Of Byte())
    For attempt As Integer = 1 To maxRetries
        Try
            renderer.RenderingOptions.Timeout = 60
            Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))
            pdf.SecuritySettings.MakePdfDocumentReadOnly()
            pdf.SecuritySettings.SetPassword("userPassword123")
            logger.LogInformation("PDF generated successfully on attempt {Attempt}", attempt)
            Return pdf.BinaryData
        Catch ex As Exception When attempt < maxRetries
            logger.LogWarning(ex, "PDF generation failed, attempt {Attempt} of {MaxRetries}", attempt, maxRetries)
            Await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)))
        End Try
    Next
    Throw New InvalidOperationException("Failed to generate PDF after retries")
End Function
$vbLabelText   $csharpLabel

Toujours valider les données d'entrée et gérer les exceptions avec élégance pour garantir une génération de PDF fiable. Envisagez la mise en place d'autorisations et de mots de passe pour les documents PDF sensibles afin de contrôler les droits d'impression, de copie et de modification.

Quelles sont les métriques de surveillance à suivre ?

Surveillez ces indicateurs clés pour la génération de PDF en production :

Indicateurs clés de production pour le suivi des performances IronPDF
Métrique Objectif Seuil d'alerte
Temps de génération Suivi des performances > 10 seconds
Utilisation de la mémoire Optimisation des ressources > 500 MB per request
Taux d'erreur Surveillance de la fiabilité > 5% failure rate
Longueur de la file d'attente planification des capacités > 100 pending
Taille du fichier Optimisation du stockage > 50 MB average

Comment déployer et dépanner la génération de PDF sur différentes plateformes ?

IronPDF prend en charge différents scénarios de déploiement sur diverses plateformes. Vous pouvez déployer sur Azure Functions, AWS Lambda ou des serveurs IIS traditionnels. La bibliothèque prend également en charge les déploiements Linux et peut s'exécuter dans des conteneurs Docker pour les architectures de microservices. Les différentes approches de déploiement offrent des avantages distincts : les conteneurs Docker assurent la cohérence, Kubernetes permet une mise à l'échelle horizontale, les fonctions sans serveur offrent une mise à l'échelle élastique et le service IronPdfEngine assure l'isolation des processus.

Quelles sont les exigences spécifiques à la plateforme que vous devez connaître ?

Chaque plateforme présente des considérations uniques lors du déploiement de la génération de PDF .NET :

Exigences et solutions de déploiement spécifiques à la plateforme pour IronPDF
Plate-forme Exigence clé Solution
Linux Polices manquantes Installez les paquets de polices via apt/yum
Docker Autorisations d'accès aux fichiers Exécuter en tant qu'utilisateur non root
Service d'application Azure Répertoire temporaire Configurer le chemin d'accès en écriture
AWS Lambda démarrages à froid Utiliser la concurrence provisionnée
macOS Signature de code Autoriser les bibliothèques non signées dans les paramètres

Les problèmes d'affichage proviennent souvent de ressources CSS ou JS manquantes, de problèmes de synchronisation pour le contenu dynamique, de polices serveur manquantes ou d'incompatibilités CSS. Un débogage efficace commence par l'activation de la journalisation détaillée via renderer.LoggingMode = IronPdf.Logging.LoggingModes.All, l'enregistrement du code HTML intermédiaire pour inspection et les tests avec JavaScript désactivé pour isoler les problèmes de rendu. La gestion de la mémoire est également cruciale : il faut toujours libérer les objets PdfDocument, traiter les tâches importantes par morceaux et définir des limites de mémoire appropriées pour le conteneur.

Pour les déploiements dans le cloud, consultez le guide de déploiement Azure et la documentation de configuration AWS Lambda. Selon la documentation Microsoft .NET , .NET 10 introduit des améliorations de performances supplémentaires qui complètent les optimisations propres à IronPDF. Pour plus de détails sur les spécifications PDF, les ressources techniques de la PDF Association fournissent un contexte utile pour comprendre les exigences de conformité PDF/A. De plus, la documentation du projet Chromium de Google décrit les comportements de rendu qui sous-tendent le moteur HTML-PDF d'IronPDF.

Quelles sont les prochaines étapes de votre processus de génération de PDF ?

IronPDF transforme la tâche complexe de création de fichiers PDF dans .NET Core en un processus simple et facile à gérer. De la création de documents de base aux fonctionnalités avancées telles que les formulaires, les images et la gestion des pages, cette bibliothèque fournit des outils pour générer des documents PDF par programmation. En convertissant du HTML en PDF, vous pouvez charger rapidement des données et produire des fichiers finis. La prise en charge par la bibliothèque de diverses normes PDF , ses fonctionnalités d'accessibilité et sa documentation complète la rendent adaptée aux applications Enterprise .

Pourquoi IronPDF est-il le bon choix pour les projets .NET ?

IronPDF se distingue comme un excellent choix pour la génération de PDF .NET :

  • Prêt pour l'entreprise : Testé et approuvé en environnement de production
  • Multiplateforme : Véritable portabilité entre les systèmes d'exploitation
  • Développement actif : Mises à jour régulières avec de nouvelles fonctionnalités
  • Grande polyvalence des formats : Prend en charge les conversions DOCX vers PDF, RTF vers PDF, image vers PDF et bien d'autres.
  • Manipulation avancée : extraction de texte et d'images, pixellisation de PDF en images, suppression de contenu et accès au DOM PDF

Comment commencer dès aujourd'hui ?

Suivez ces étapes pour démarrer votre processus de génération de PDF :

  1. Installez IronPDF : ajoutez-le via NuGet à votre projet .NET 10.
  2. Essayez des exemples simples : commencez par une conversion HTML vers PDF.
  3. Explorez les fonctionnalités avancées : ajoutez des formulaires, des signatures et des paramètres de sécurité.
  4. Optimisation des performances : mise en œuvre de la mise en cache, du traitement asynchrone et de la réutilisation du moteur de rendu
  5. Déploiement en production : Choisissez la stratégie d'hébergement appropriée

Que vous créiez des rapports simples ou des documents complexes de plusieurs pages, l'API intuitive et le moteur de rendu performant d'IronPDF en font un choix pratique pour les développeurs .NET . Commencez à créer des fichiers PDF professionnels dans vos applications ASP.NET Core dès aujourd'hui avec l'essai gratuit d'IronPDF. Prêt à ajouter des fonctionnalités de génération de PDF à votre application ? Lancez-vous avec IronPDF et découvrez à quel point la création de PDF peut être simple. Pour accéder à des ressources d'apprentissage supplémentaires, consultez les tutoriels complets , les exemples de code et la documentation des fonctionnalités .

Questions Fréquemment Posées

Quelle est la fonction principale d'IronPDF dans les applications ASP.NET ?

IronPDF permet aux développeurs de créer des documents PDF sans effort au sein d'applications ASP.NET, rationalisant ainsi des tâches telles que la génération de factures, de rapports et d'autres systèmes basés sur des documents.

Pourquoi la création programmatique de documents PDF est-elle importante dans les applications web modernes ?

La création programmatique de documents PDF est essentielle car elle permet l'automatisation et la génération de contenu dynamique pour les applications qui nécessitent une gestion des documents, telles que les systèmes de facturation et les rapports de données.

Puis-je utiliser IronPDF pour générer des PDF dans des environnements .NET Core ?

Oui, IronPDF est une puissante bibliothèque .NET Core spécialement conçue pour simplifier la génération de PDF, ce qui en fait un choix idéal pour créer des fichiers PDF dans les applications .NET Core.

Quels types de documents puis-je créer à l'aide d'IronPDF for .NET Core ?

Avec IronPDF, vous pouvez créer un large éventail de documents, notamment des factures, des rapports et tout système basé sur des documents qui nécessite une génération PDF efficace.

Où puis-je trouver plus de détails techniques sur l'utilisation d'IronPDF ?

Des détails techniques complets sur l'utilisation d'IronPDF peuvent être trouvés dans la documentation officielle, qui fournit des conseils étape par étape et des astuces pratiques.

Comment IronPDF améliore-t-il les capacités de génération de PDF dans les applications ASP.NET ?

IronPDF améliore les capacités de génération de PDF en fournissant une bibliothèque robuste qui simplifie la création, la manipulation et la gestion des documents PDF directement au sein des applications ASP.NET.

IronPDF est-il adapté à la création de systèmes basés sur des documents dans .NET Core ?

Oui, IronPDF est tout à fait adapté à la construction de systèmes basés sur des documents dans .NET Core, car il offre un moyen transparent de générer et de gérer des PDF de manière programmatique.

Quelles sont les meilleures méthodes pour gérer la création de PDF dans .NET Core à l'aide d'IronPDF ?

Le tutoriel explore diverses méthodes pour gérer la création de PDF, en se concentrant sur l'exploitation des fonctionnalités d'IronPDF pour générer et gérer efficacement des documents PDF dans les environnements .NET Core.

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