Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de ironpdf
  4. Imprimer un formulaire C# en PDF
UTILISATION DE IRONPDF

Imprimer un formulaire en PDF en utilisant IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

Imprimer un formulaire Windows en PDF en C# est simple avec IronPDF: générez la représentation HTML du formulaire à l'aide de ChromePdfRenderer, enregistrez-la sur disque ou en mémoire, et produisez un PDF pixel-perfect en quelques lignes de code seulement.

L'exportation d'une application Windows Forms au format PDF est une exigence courante dans les logiciels métiers. Que vous ayez besoin d'archiver des écrans de saisie de données, de générer des rapports destinés aux clients à partir de l'état d'un formulaire ou de capturer des aperçus avant impression sans toucher à l'imprimante, la conversion d'un formulaire C# en PDF simplifie les flux de travail quotidiens. IronPDF fournit une API native .NET qui gère le pipeline de conversion du rendu HTML à la sortie PDF finale, vous permettant ainsi d'éviter les solutions de contournement fragiles de l'impression GDI+.

Comment installer IronPDF?

Ajoutez IronPDF à votre projet via NuGet. Ouvrez la console du gestionnaire de packages et exécutez :

Install-Package IronPdf
Install-Package IronPdf
SHELL

Ou utilisez le .NET CLI :

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Après l'installation, ajoutez using IronPdf; en haut de tout fichier qui appelle l'API. Le package est également disponible directement sur NuGet . Une clé de licence d'essai gratuite est disponible sur IronPDF pour débloquer une sortie sans filigrane pendant l'évaluation.

Comment convertir un formulaire Windows en PDF en utilisant HTML ?

La méthode la plus fiable pour convertir un formulaire C# en PDF consiste à créer un instantané HTML des données du formulaire et à rendre cet instantané avec ChromePdfRenderer. Cette approche découple le rendu visuel de la surface GDI+ de WinForms, offrant ainsi une sortie nette et portable qui s'affiche de manière identique sur tous les visualiseurs PDF.

using IronPdf;

// Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY";

// Compose an HTML representation of your form data
string formHtml = $"""
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class="box">
            <div class="row"><label>Full Name:</label> Jane Smith</div>
            <div class="row"><label>Email:</label> jane@example.com</div>
            <div class="row"><label>Phone:</label> +1 555-0100</div>
            <div class="row"><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    """;

// Render HTML to PDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize       = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop       = 20;
renderer.RenderingOptions.MarginBottom    = 20;
renderer.RenderingOptions.MarginLeft      = 25;
renderer.RenderingOptions.MarginRight     = 25;
renderer.RenderingOptions.CssMediaType    = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("CustomerForm.pdf");

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).");
using IronPdf;

// Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY";

// Compose an HTML representation of your form data
string formHtml = $"""
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class="box">
            <div class="row"><label>Full Name:</label> Jane Smith</div>
            <div class="row"><label>Email:</label> jane@example.com</div>
            <div class="row"><label>Phone:</label> +1 555-0100</div>
            <div class="row"><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    """;

// Render HTML to PDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize       = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop       = 20;
renderer.RenderingOptions.MarginBottom    = 20;
renderer.RenderingOptions.MarginLeft      = 25;
renderer.RenderingOptions.MarginRight     = 25;
renderer.RenderingOptions.CssMediaType    = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("CustomerForm.pdf");

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).");
Imports IronPdf

' Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY"

' Compose an HTML representation of your form data
Dim formHtml As String = $"
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset='utf-8'>
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class='box'>
            <div class='row'><label>Full Name:</label> Jane Smith</div>
            <div class='row'><label>Email:</label> jane@example.com</div>
            <div class='row'><label>Phone:</label> +1 555-0100</div>
            <div class='row'><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    "

' Render HTML to PDF
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
renderer.RenderingOptions.PrintHtmlBackgrounds = True

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)
pdf.SaveAs("CustomerForm.pdf")

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).")
$vbLabelText   $csharpLabel

Le ChromePdfRenderer pilote un moteur Chromium sans interface graphique, de sorte que les mises en page CSS, les polices intégrées et même les requêtes de médias imprimés s'affichent fidèlement. Remplacez les valeurs de champ codées en dur par des données liées aux contrôles de votre formulaire lors de l'exécution pour une approche entièrement dynamique. Le guide pratique de conversion HTML vers PDF couvre en détail toutes les options de rendu disponibles.

Comment extraire des données en direct des contrôles de formulaire ?

Au lieu de coder manuellement le HTML, lisez directement les valeurs de vos contrôles WinForms et injectez-les dans le modèle :

using IronPdf;

// Called from a button click handler in your WinForms application
void ExportFormToPdf()
{
    // Read control values at the moment of export
    string name    = txtName.Text;
    string email   = txtEmail.Text;
    string phone   = txtPhone.Text;
    string notes   = rtbNotes.Text.Replace("\n", "<br>");

    string html = $"""
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        """;

    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

    // Prompt the user for a save location
    using var dialog = new SaveFileDialog();
    dialog.Filter   = "PDF Files|*.pdf";
    dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";

    if (dialog.ShowDialog() == DialogResult.OK)
    {
        pdf.SaveAs(dialog.FileName);
        MessageBox.Show("PDF exported successfully.", "Export Complete");
    }
}
using IronPdf;

// Called from a button click handler in your WinForms application
void ExportFormToPdf()
{
    // Read control values at the moment of export
    string name    = txtName.Text;
    string email   = txtEmail.Text;
    string phone   = txtPhone.Text;
    string notes   = rtbNotes.Text.Replace("\n", "<br>");

    string html = $"""
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        """;

    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

    // Prompt the user for a save location
    using var dialog = new SaveFileDialog();
    dialog.Filter   = "PDF Files|*.pdf";
    dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";

    if (dialog.ShowDialog() == DialogResult.OK)
    {
        pdf.SaveAs(dialog.FileName);
        MessageBox.Show("PDF exported successfully.", "Export Complete");
    }
}
Imports IronPdf

' Called from a button click handler in your WinForms application
Sub ExportFormToPdf()
    ' Read control values at the moment of export
    Dim name As String = txtName.Text
    Dim email As String = txtEmail.Text
    Dim phone As String = txtPhone.Text
    Dim notes As String = rtbNotes.Text.Replace(vbLf, "<br>")

    Dim html As String = $"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        "

    Dim renderer As New ChromePdfRenderer()
    Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)

    ' Prompt the user for a save location
    Using dialog As New SaveFileDialog()
        dialog.Filter = "PDF Files|*.pdf"
        dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf"

        If dialog.ShowDialog() = DialogResult.OK Then
            pdf.SaveAs(dialog.FileName)
            MessageBox.Show("PDF exported successfully.", "Export Complete")
        End If
    End Using
End Sub
$vbLabelText   $csharpLabel

Ce fragment de code traite l'exportation du formulaire comme une mini-tâche de reporting : collecter les valeurs des champs, les intégrer dans un modèle HTML, effectuer le rendu, puis enregistrer à l'emplacement choisi par l'utilisateur. Vous pouvez étendre le tableau HTML avec autant de champs que le formulaire en contient. Pour les formulaires à plusieurs onglets, créez des blocs <section> séparés par onglet et laissez IronPDF paginer naturellement.

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

Les en-têtes et pieds de page permettent de peaufiner un formulaire exporté pour un usage Professional . La classe TextHeaderFooter d'IronPDF ajoute du texte en haut et en bas de chaque page sans modifier le code HTML du corps :

using IronPdf;
using IronPdf.Rendering;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Stamp header and footer on every page
pdf.AddTextHeaders(new TextHeaderFooter
{
    CenterText      = "Confidential -- Internal Use Only",
    LeftText        = "{date}",
    RightText       = "Page {page} of {total-pages}",
    FontSize        = 9,
    DrawDividerLine = true
});

pdf.AddTextFooters(new TextHeaderFooter
{
    CenterText = "Generated by MyApp v2.0",
    FontSize   = 8
});

pdf.SaveAs("FormWithHeader.pdf");
using IronPdf;
using IronPdf.Rendering;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Stamp header and footer on every page
pdf.AddTextHeaders(new TextHeaderFooter
{
    CenterText      = "Confidential -- Internal Use Only",
    LeftText        = "{date}",
    RightText       = "Page {page} of {total-pages}",
    FontSize        = 9,
    DrawDividerLine = true
});

pdf.AddTextFooters(new TextHeaderFooter
{
    CenterText = "Generated by MyApp v2.0",
    FontSize   = 8
});

pdf.SaveAs("FormWithHeader.pdf");
Imports IronPdf
Imports IronPdf.Rendering

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Stamp header and footer on every page
pdf.AddTextHeaders(New TextHeaderFooter With {
    .CenterText = "Confidential -- Internal Use Only",
    .LeftText = "{date}",
    .RightText = "Page {page} of {total-pages}",
    .FontSize = 9,
    .DrawDividerLine = True
})

pdf.AddTextFooters(New TextHeaderFooter With {
    .CenterText = "Generated by MyApp v2.0",
    .FontSize = 8
})

pdf.SaveAs("FormWithHeader.pdf")
$vbLabelText   $csharpLabel

Les jetons dynamiques tels que {page}, {total-pages} et {date} sont résolus automatiquement lors du rendu. Pour une version personnalisée, remplacez TextHeaderFooter par HtmlHeaderFooter et fournissez le balisage HTML complet, y compris les logos de l'entreprise. Le guide pratique relatif aux en-têtes et pieds de page présente toutes les options de jetons et de mise en page disponibles.

Comment convertir un formulaire en tableau d'octets plutôt qu'en fichier ?

L'enregistrement direct sur disque est pratique, mais de nombreuses applications doivent transmettre le PDF via HTTP, le stocker dans une base de données ou le transmettre à un service en aval. Dans ces cas-là, il est préférable d'ignorer le fichier et de travailler directement avec les données brutes.

using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Get raw bytes -- no file required
byte[] pdfBytes = pdf.BinaryData;

// Alternatively, get a MemoryStream for APIs that accept streams
using System.IO.MemoryStream stream = pdf.Stream;
byte[] fromStream = stream.ToArray();

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes");

// Example: return as HTTP response in ASP.NET Core
// return File(pdfBytes, "application/pdf", "form-export.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Get raw bytes -- no file required
byte[] pdfBytes = pdf.BinaryData;

// Alternatively, get a MemoryStream for APIs that accept streams
using System.IO.MemoryStream stream = pdf.Stream;
byte[] fromStream = stream.ToArray();

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes");

// Example: return as HTTP response in ASP.NET Core
// return File(pdfBytes, "application/pdf", "form-export.pdf");
Imports IronPdf
Imports System.IO

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Get raw bytes -- no file required
Dim pdfBytes As Byte() = pdf.BinaryData

' Alternatively, get a MemoryStream for APIs that accept streams
Using stream As MemoryStream = pdf.Stream
    Dim fromStream As Byte() = stream.ToArray()
End Using

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes")

' Example: return as HTTP response in ASP.NET Core
' Return File(pdfBytes, "application/pdf", "form-export.pdf")
$vbLabelText   $csharpLabel

La propriété BinaryData effectue une copie O(1) du tableau d'octets précalculé. La propriété Stream renvoie une nouvelle MemoryStream qui prend en charge l'accès consultable pour les bibliothèques qui attendent des entrées de flux -- utile lors de l'enchaînement de la compression ou du chiffrement avant de livrer les octets finaux. Vous trouverez plus de détails sur la gestion des PDF en mémoire dans le guide sur les flux de mémoire PDF .

Comment appliquer les paramètres de sécurité avant d'enregistrer ?

Les formulaires exportés contiennent souvent des données sensibles. L'API de sécurité d'IronPDF chiffre le PDF et restreint ce que les destinataires peuvent en faire :

using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Restrict access
pdf.SecuritySettings.OwnerPassword          = "adminSecretKey";
pdf.SecuritySettings.UserPassword           = "viewerPass";
pdf.SecuritySettings.AllowUserPrinting      = true;   // allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = false; // block copy
pdf.SecuritySettings.AllowUserAnnotations   = false;

pdf.SaveAs("SecureForm.pdf");
Console.WriteLine("Password-protected PDF created.");
using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Restrict access
pdf.SecuritySettings.OwnerPassword          = "adminSecretKey";
pdf.SecuritySettings.UserPassword           = "viewerPass";
pdf.SecuritySettings.AllowUserPrinting      = true;   // allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = false; // block copy
pdf.SecuritySettings.AllowUserAnnotations   = false;

pdf.SaveAs("SecureForm.pdf");
Console.WriteLine("Password-protected PDF created.");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Restrict access
pdf.SecuritySettings.OwnerPassword = "adminSecretKey"
pdf.SecuritySettings.UserPassword = "viewerPass"
pdf.SecuritySettings.AllowUserPrinting = True ' allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = False ' block copy
pdf.SecuritySettings.AllowUserAnnotations = False

pdf.SaveAs("SecureForm.pdf")
Console.WriteLine("Password-protected PDF created.")
$vbLabelText   $csharpLabel

La définition d'un mot de passe propriétaire permet aux administrateurs de contrôler les indicateurs d'autorisation, tandis que le mot de passe utilisateur restreint totalement l'accès aux documents. L'indicateur AllowUserPrinting est particulièrement pertinent ici -- vous pouvez permettre au destinataire de réimprimer le formulaire exporté sans lui accorder de droits de modification. Tous les détails figurent dans le guide des autorisations et des mots de passe au format PDF .

Comment comparer les approches d'impression pour les formulaires C# ?

Le choix entre la capture bitmap native de WinForms (PrintDocument), la capture bitmap GDI+ et le rendu HTML d'IronPDF dépend de compromis en matière de fidélité, de complexité et de portabilité :

Comparaison des approches de conversion de formulaires C# en PDF
Approche Fidélité de sortie Complexité du code Multiplateforme Support CSS Idéal pour
Pilote d'imprimante PrintDocument + PDF Moyen Moyen Windows uniquement Aucune Formulaires WinForms hérités avec logique d'impression existante
Capture d'image bitmap GDI+ (Control.DrawToBitmap) Haute (raster) Faible Windows uniquement Aucune Captures rapides de type capture d'écran
Rendu HTML de IronPDF Haut (vecteur) Faible Windows, Linux, macOS, Docker CSS3 complet Exportations Professional, portables et basées sur les données
ReportViewer (RDLC) Haut Haut Windows uniquement Limitée Rapports paginés complexes avec regroupement

L'approche d'IronPDF, basée sur HTML, produit des PDF vectoriels dont la mise à l'échelle est impeccable quel que soit le niveau de Zoom et qui s'impriment avec une grande netteté sur tous les appareils. Grâce à son moteur de rendu Chromium, les requêtes média CSS, les mises en page Flexbox et les polices Google fonctionnent parfaitement ; contrairement à la capture bitmap GDI+. La bibliothèque fonctionne également sous Linux et dans des conteneurs Docker , ce qui en fait la seule option de ce tableau qui fonctionne en dehors de Windows.

Que se passe-t-il lorsque le formulaire comporte plusieurs onglets ?

Les formulaires WinForms à onglets multiples sont courants dans les applications d'entreprise. Étant donné que le PDF est généré à partir de HTML plutôt qu'à partir de la surface GDI+ en direct, vous contrôlez précisément le contenu des onglets qui apparaissent. Créez une section HTML par onglet et concaténez-les avant le rendu. Le pipeline passe des chaînes HTML des onglets à travers ChromePdfRenderer pour aboutir à un seul PDF multipage continu -- une section logique par onglet. Vous pouvez également générer chaque onglet indépendamment et fusionner les objets PdfDocument résultants avec l'API de fusion d'IronPDF .

Comment gérez-vous la validation des formulaires avant l'exportation ?

Exporter uniquement les données de formulaire valides. Un modèle de protection simple empêche la génération de PDF à partir de soumissions incomplètes : valider d'abord les champs, et ne procéder à la génération et au rendu HTML que lorsque tous les champs obligatoires sont validés. Si un champ quelconque présente une erreur, mettez-la en évidence dans l'interface utilisateur et annulez l'exportation. Cela permet de garantir la cohérence des fichiers PDF exportés et d'éviter toute confusion ultérieure due à des données partielles. Selon la documentation de Microsoft sur la validation des formulaires Windows , ErrorProvider est le mécanisme standard pour le retour d'information de validation au niveau du champ avant toute action.

Comment diffuser le fichier PDF exporté depuis ASP.NET Core?

Les formulaires Web construits avec ASP.NET Core peuvent être exportés au format PDF en utilisant la même API ChromePdfRenderer. Les octets rendus sont renvoyés directement sous forme de fichier :

using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/forms")]
public class FormExportController : ControllerBase
{
    [HttpPost("export")]
    public IActionResult ExportFormAsPdf([FromBody] FormDataModel formData)
    {
        // Build HTML from submitted form data
        string html = $"""
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            """;

        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

        PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
        byte[] pdfBytes = pdf.BinaryData;

        string fileName = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf";
        return File(pdfBytes, "application/pdf", fileName);
    }
}

public record FormDataModel(string FormTitle, string ApplicantName, string ReferenceId);
using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/forms")]
public class FormExportController : ControllerBase
{
    [HttpPost("export")]
    public IActionResult ExportFormAsPdf([FromBody] FormDataModel formData)
    {
        // Build HTML from submitted form data
        string html = $"""
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            """;

        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

        PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
        byte[] pdfBytes = pdf.BinaryData;

        string fileName = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf";
        return File(pdfBytes, "application/pdf", fileName);
    }
}

public record FormDataModel(string FormTitle, string ApplicantName, string ReferenceId);
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/forms")>
Public Class FormExportController
    Inherits ControllerBase

    <HttpPost("export")>
    Public Function ExportFormAsPdf(<FromBody> formData As FormDataModel) As IActionResult
        ' Build HTML from submitted form data
        Dim html As String = $"
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            "

        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

        Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
        Dim pdfBytes As Byte() = pdf.BinaryData

        Dim fileName As String = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf"
        Return File(pdfBytes, "application/pdf", fileName)
    End Function
End Class

Public Class FormDataModel
    Public Property FormTitle As String
    Public Property ApplicantName As String
    Public Property ReferenceId As String

    Public Sub New(formTitle As String, applicantName As String, referenceId As String)
        Me.FormTitle = formTitle
        Me.ApplicantName = applicantName
        Me.ReferenceId = referenceId
    End Sub
End Class
$vbLabelText   $csharpLabel

Ce contrôleur reçoit les données du formulaire au format JSON, génère le PDF en mémoire et le renvoie sous forme de fichier à télécharger. Aucun fichier temporaire n'est créé sur le serveur. Pour les applications Blazor , l'approche est similaire : appeler le même code de rendu à partir d'un service et envoyer les octets au navigateur via IJSRuntime. Les modèles d'intégration ASP.NET complets sont documentés dans le guide ASP.NET vers PDF .

Quel type MIME et quelle disposition de contenu devez-vous utiliser ?

Toujours renvoyer application/pdf comme type de contenu. Utilisez Content-Disposition: inline pour afficher le PDF dans le navigateur, ou Content-Disposition: attachment pour forcer un téléchargement. Le nom du fichier apparaît dans la boîte de dialogue d'enregistrement du navigateur lorsque attachment est utilisé, choisissez donc un nom significatif qui inclut un identifiant de référence ou une date.

Comment mettre en cache les PDF générés ?

Si la même exportation de formulaire est demandée à plusieurs reprises, mettez en cache le tableau d'octets pour éviter un nouveau rendu. IMemoryCache fonctionne pour les déploiements sur un seul serveur ; Utilisez un cache distribué tel que Redis pour les configurations multi-instances. Définissez une date d'expiration qui corresponde à la fréquence de modification des données du formulaire sous-jacent.

Quelles sont les meilleures pratiques pour l'exportation de formulaires vers des fichiers PDF ?

L'exportation de formulaires cohérents et de haute qualité repose sur quelques modèles répétables :

  • Privilégiez un HTML simple. Évitez les modèles riches en JavaScript : le HTML et le CSS purs s'affichent plus rapidement et produisent des PDF plus légers. Activez RenderingOptions.EnableJavaScript uniquement lorsque les calculs du formulaire en dépendent.
  • Utilisez le CSS d'impression. Définissez les règles CssMediaType = PdfCssMediaType.Print et @media print dans votre feuille de style. Cela permet d'éliminer du PDF exporté les éléments graphiques qui ne s'affichent qu'à l'écran, tels que les barres de navigation et les barres latérales.
  • Nettoyez les données saisies par l'utilisateur. Échappez les entités HTML dans toute valeur de champ que vous injectez dans le modèle afin d'éviter un balisage incorrect ou, dans des cas particuliers, l'injection de scripts dans le PDF.
  • Supprimer les objets PdfDocument. Les ressources non gérées sont conservées jusqu'à leur suppression. Utilisez les déclarations using ou appelez explicitement Dispose() après l'enregistrement.
  • Effectuez des tests avec des données de production. Les formulaires contenant du texte long, des caractères spéciaux ou des images intégrées peuvent donner des mises en page surprenantes. Effectuez des exportations sur des échantillons de données réelles pendant le développement.

La documentation de référence des options de rendu répertorie tous les paramètres disponibles, des formats de papier personnalisés aux marges personnalisées et à l'orientation de la page .

Comment gérez-vous les formulaires volumineux ou de plusieurs pages ?

IronPDF gère la pagination automatiquement en fonction de la hauteur du contenu et du format de papier sélectionné. Insérez page-break-before: always sur les conteneurs de section dans le CSS lorsqu'une nouvelle section de formulaire doit toujours commencer sur une nouvelle page. Pour les formulaires comportant des centaines de champs, la pré-allocation d'un MemoryStream avec une capacité estimée réduit la pression du GC pendant la copie du tableau d'octets.

Comment ajouter une signature numérique ?

Les exportations de formulaires signés ont une valeur juridique dans de nombreuses juridictions. IronPDF prend en charge les certificats numériques stockés dans des fichiers PFX ou dans les magasins de certificats Windows :

// Load the certificate and sign in one step
var signature = new IronPdf.Signing.PdfSignature("certificate.pfx", "certPassword");
pdf.Sign(signature);
pdf.SaveAs("SignedForm.pdf");
// Load the certificate and sign in one step
var signature = new IronPdf.Signing.PdfSignature("certificate.pfx", "certPassword");
pdf.Sign(signature);
pdf.SaveAs("SignedForm.pdf");
Imports IronPdf.Signing

' Load the certificate and sign in one step
Dim signature As New PdfSignature("certificate.pfx", "certPassword")
pdf.Sign(signature)
pdf.SaveAs("SignedForm.pdf")
$vbLabelText   $csharpLabel

Selon la présentation des signatures numériques Adobe PDF , une signature numérique certifie l'origine du document et détecte toute modification apportée après la signature. Le guide de signature numérique au format PDF couvre en détail la configuration des certificats et les champs de signature visibles.

Quels sont les points clés à retenir ?

La conversion d'un formulaire Windows C# en PDF avec IronPDF se réduit à trois étapes : construire une représentation HTML des données du formulaire, la transmettre à ChromePdfRenderer, et enregistrer ou transmettre le résultat. Cette approche produit des PDF vectoriels qui s'impriment avec netteté, fonctionnent sur différentes plateformes et prennent en charge l'intégralité du modèle de mise en page CSS3 — des avantages que les méthodes de capture bitmap GDI+ et les pilotes d'impression traditionnels ne peuvent égaler.

Principales fonctionnalités abordées dans ce guide :

  • Rendu HTML vers PDF avec ChromePdfRenderer pour WinForms et ASP.NET Core
  • Liaison de données en direct des contrôles WinForms vers les modèles HTML
  • En-têtes, pieds de page et numérotation des pages avec TextHeaderFooter
  • Sortie de tableau d'octets en mémoire via BinaryData pour les réponses HTTP et le stockage de bases de données
  • Paramètres de sécurité des fichiers PDF : mots de passe du propriétaire/utilisateur et indicateurs d'autorisation
  • Signature numérique pour les exportations juridiquement contraignantes

Explorez les fonctionnalités IronPDF pour découvrir les outils d'annotation, l'édition des champs de formulaire, la conformité PDF/A et bien plus encore. Essayez IronPDF gratuitement grâce à une licence d'essai de 30 jours et intégrez-le dès aujourd'hui à votre flux de travail d'exportation de formulaires.

Questions Fréquemment Posées

Comment puis-je convertir un formulaire C# en PDF à l'aide d'IronPDF ?

Vous pouvez convertir un formulaire C# en PDF à l'aide d'IronPDF en utilisant son API intuitive, qui vous permet de gérer efficacement les conversions PDF sans code complexe.

Pourquoi est-il important de convertir des documents PDF en tableaux d'octets dans les applications .NET ?

Convertir des documents PDF en tableaux d'octets est important car cela permet le stockage des PDF dans des bases de données, la transmission via des API et la gestion du contenu des documents en mémoire, qui sont toutes des opérations critiques dans les applications modernes de .NET.

Quels sont les avantages d'utiliser IronPDF pour la conversion de tableaux d'octets ?

IronPDF simplifie la conversion des tableaux d'octets en fournissant une API facile à utiliser qui rationalise le processus, réduisant le besoin de code complexe et améliorant l'efficacité du développement.

IronPDF peut-il gérer la conversion PDF en mémoire ?

Oui, IronPDF peut gérer la conversion PDF en mémoire, permettant aux développeurs de gérer le contenu des documents sans avoir besoin d'enregistrer les fichiers sur le disque.

Est-il possible de stocker les PDF dans une base de données à l'aide d'IronPDF ?

Oui, vous pouvez stocker des PDF dans une base de données en les convertissant en tableaux d'octets à l'aide d'IronPDF, ce qui facilite une intégration transparente avec les systèmes de bases de données.

Comment IronPDF aide-t-il à transmettre les fichiers PDF via les API ?

IronPDF aide à transmettre les fichiers PDF via les API en permettant la conversion des PDF en tableaux d'octets, facilitant ainsi l'envoi et la réception de données de documents sur les protocoles réseau.

Qu'est-ce qui rend l'API d'IronPDF intuitive pour les développeurs ?

L'API d'IronPDF est conçue pour être intuitive pour les développeurs en fournissant des méthodes claires et simples qui simplifient les opérations PDF complexes, améliorant la productivité et réduisant les courbes d'apprentissage.

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