1. IronPDF
  2. Tutoriels
  3. Génération de PDF .NET Core
Comment générer des fichiers PDF dans .NET Core

Convertir du HTML en PDF dans .NET Core à l'aide de C# avec IronPDF

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
Mis à jour:
This article was translated from English: Does it need improvement?
Translated
View the article in English

La génération de fichiers PDF haute fidélité directement à partir de HTML est une exigence courante dans les applications .NET modernes : les rapports, les factures et les tickets nécessitent tous un rendu au pixel près qui corresponde à l'interface utilisateur web. IronPDF rationalise ce flux de travail en proposant une API C# unique permettant de convertir du code HTML, des vues Razor et des sites web complets en documents PDF conformes aux normes. À la fin de ce guide, un développeur sera capable de convertir des URL, du code HTML brut ou des vues MVC dans un projet .NET Core, et de déployer le même code sur Windows, Linux, Docker ou dans des environnements sans serveur.

ConseilsPour les problèmes de mise en page, IronPDF fournit un débogueur Headless Chrome qui aide à diagnostiquer les anomalies CSS, JavaScript et de requêtes média avant le rendu du PDF. Consultez le guide dédié à la conversion HTML-PDF au pixel près pour découvrir des techniques approfondies.

Guide de démarrage rapide : Créer un PDF à partir de HTML dans .NET Core

Convertissez sans effort du HTML en PDF dans .NET Core à l'aide de la bibliothèque IronPDF. Ce guide fournit un exemple simple pour vous permettre de démarrer rapidement en convertissant du contenu HTML en un PDF de haute qualité avec un minimum de code. Idéal pour les développeurs qui souhaitent intégrer facilement la création de PDF dans leurs applications.

  1. Installez IronPDF avec le Gestionnaire de Packages NuGet

    PM > Install-Package IronPdf

  2. Copiez et exécutez cet extrait de code.

    var pdf = new IronPdf.ChromePdfRenderer().RenderHtmlAsPdf("<h1>Hello World</h1>");

  3. Déployez pour tester sur votre environnement de production.

    Commencez à utiliser IronPDF dans votre projet dès aujourd'hui avec un essai gratuit

    arrow pointer

Workflow minimal (5 étapes)

  1. Installez le IronPdf package NuGet
  2. Convertir l'URL d'un site web avec RenderUrlAsPdf
  3. Afficher le code HTML brut via RenderHtmlAsPdf
  4. Exporter une vue MVC au format PDF
  5. Ajuster le format du papier, les marges, les en-têtes et les pieds de page

Liste de contrôle pour un démarrage rapide

  1. Installation – Install-Package IronPdf
  2. Afficher une URL – ChromePdfRenderer.RenderUrlAsPdf()
  3. Afficher le code HTML brut – ChromePdfRenderer.RenderHtmlAsPdf()
  4. Exporter une vue Razor – ChromePdfRenderer.RenderHtmlAsPdfAsync()
  5. Affiner le résultat – utiliser ChromePdfRenderer.RenderingOptions

Contenu de ce tutoriel

  • Conversion d'URL, de chaînes HTML et de vues Razor
  • Configuration du papier, des marges et du type de support
  • Déploiement multiplateforme (Windows, Linux, Docker)
  • Post-traitement : fusionner, ajouter un filigrane, protéger par mot de passe et signer numériquement des fichiers PDF
  • Exemple complet : application MVC de réservation de billets

Comment installer la bibliothèque PDF dans .NET Core ?

L'installation de la bibliothèque se fait en une seule ligne de code dans n'importe quel projet .NET 8 et reste compatible avec la préversion de .NET 9 et la prochaine version de .NET 10. Utilisez la console du Package Manager NuGet et le Package Manager résoudra automatiquement toutes les dépendances pour les cibles Windows, Linux, Docker et sans serveur.

PM> Install-Package IronPdf             # .NET 8 LTS and higher
PM> Install-Package IronPdf             # .NET 8 LTS and higher
SHELL

Veuillez noterBesoin de la CLI ? La même commande fonctionne avec dotnet add package IronPdf dans le dossier de votre projet.

Une fois l'installation terminée, vérifiez que tout fonctionne correctement en convertissant n'importe quelle URL publique :

// Program.cs — .NET 8 LTS
using IronPdf;

var renderer = new ChromePdfRenderer();

// Render a live website to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://example.com");

// Persist to disk
pdf.SaveAs("website-snapshot.pdf");
// Program.cs — .NET 8 LTS
using IronPdf;

var renderer = new ChromePdfRenderer();

// Render a live website to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://example.com");

// Persist to disk
pdf.SaveAs("website-snapshot.pdf");
' Program.cs — .NET 8 LTS
Imports IronPdf

Private renderer = New ChromePdfRenderer()

' Render a live website to PDF
Private PdfDocument As using

' Persist to disk
pdf.SaveAs("website-snapshot.pdf")
$vbLabelText   $csharpLabel

Comment ça marche

  • ChromePdfRenderer lance en arrière-plan une instance Chromium en mode sandbox — aucune installation séparée de Chrome n'est requise.
  • RenderUrlAsPdf capture le DOM entièrement rendu, y compris le contenu piloté par JavaScript, les requêtes média CSS et les polices.
  • Le résultat PdfDocument expose des méthodes d'aide permettant de fusionner, de protéger par mot de passe ou de signer numériquement la sortie — des fonctionnalités abordées plus loin dans ce tutoriel.

Pour plus de détails sur les nuances de déploiement (Azure App Service, AWS Lambda, Linux sur site), consultez le guide d'installation dédié et les pages de configuration avancée de NuGet. Les conseils internes en matière de CI/CD pour les clusters Docker et K8s sont abordés dans les bonnes pratiques de déploiement Docker.

Comment un service .NET Core peut-il convertir l'URL d'un site web en ligne au format PDF ?

Un simple appel à RenderUrlAsPdf suffit : transmettez n'importe quelle URL accessible au public et IronPDF renvoie un PDF entièrement rendu et conforme aux normes. Le code ci-dessous cible .NET 8 LTS et se compile sans modification sur la préversion de .NET 9 ainsi que sur la prochaine version .NET 10 prévue pour 2025.

Exemple étape par étape

// Program.cs — .NET 8 LTS-compatible
using IronPdf;

// 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// 2. Create a reusable renderer instance
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        // Force A4 portrait output and apply @media print styles
        PaperSize    = PdfPaperSize.A4,
        CssMediaType = PdfCssMediaType.Print
    }
};

// 3. Convert Microsoft Docs home page to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://learn.microsoft.com/");

// 4. Save the PDF or stream it from a Web API
pdf.SaveAs("docs-offline-copy.pdf");
// Program.cs — .NET 8 LTS-compatible
using IronPdf;

// 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// 2. Create a reusable renderer instance
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        // Force A4 portrait output and apply @media print styles
        PaperSize    = PdfPaperSize.A4,
        CssMediaType = PdfCssMediaType.Print
    }
};

// 3. Convert Microsoft Docs home page to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://learn.microsoft.com/");

// 4. Save the PDF or stream it from a Web API
pdf.SaveAs("docs-offline-copy.pdf");
' Program.cs — .NET 8 LTS-compatible
Imports IronPdf

' 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' 2. Create a reusable renderer instance
Dim renderer = New ChromePdfRenderer With {
	.RenderingOptions = {
		PaperSize = PdfPaperSize.A4,
		CssMediaType = PdfCssMediaType.Print
	}
}

' 3. Convert Microsoft Docs home page to PDF
Using pdf As PdfDocument = renderer.RenderUrlAsPdf("https://learn.microsoft.com/")
	
	' 4. Save the PDF or stream it from a Web API
	pdf.SaveAs("docs-offline-copy.pdf")
End Using
$vbLabelText   $csharpLabel

Pourquoi cela fonctionne

  • ChromePdfRenderer lance une instance Chromium en mode sandbox — aucune dépendance au Chrome du système, ce qui permet de conserver des images Docker légères.
  • RenderUrlAsPdf attend que le DOM et JavaScript aient terminé avant de créer un instantané, afin que les applications monopages s'affichent correctement.
  • Définir CssMediaType sur PRINT indique au moteur d'utiliser des règles spécifiques à l'impression, correspondant à la sortie Imprimer → Enregistrer au format PDF d'un navigateur.
  • Le résultat PdfDocument peut être chiffré, signé numériquement, fusionné ou rasterisé — des fonctionnalités abordées dans les sections suivantes.

ConseilsDébogage au pixel près : activez renderer.LoggingOptions.DebugMode = true et suivez le guide de débogage Headless Chrome pour inspecter les DevTools en direct pendant le rendu.

Ressources connexes

Comment convertir du code HTML brut en PDF dans .NET Core ?

Le fait de passer une chaîne HTML — ou le balisage rendu d'une vue Razor — à ChromePdfRenderer.RenderHtmlAsPdf génère instantanément un PDF conforme aux normes. La méthode lance le moteur Chromium intégré d'IronPDF, ce qui évite d'avoir à installer un navigateur externe ou à dépendre de WebView. Le même code présenté ci-dessous se compile aujourd'hui sur .NET 8 LTS et reste compatible avec les versions futures de .NET 9 et de .NET 10, dont la sortie est prévue en novembre 2025.

Exemple — générer un PDF à partir d'un fragment HTML

// Program.cs — compatible with .NET 8 and newer
using IronPdf;

// Sample HTML fragment (could also be read from a file, Razor view, or CMS)
const string html = """
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>
""";

// 1. Create a renderer once and reuse it across conversions
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        PaperSize    = PdfPaperSize.A4,                  // ISO-standard paper size
        PaperOrientation = PdfPaperOrientation.Portrait,
        CssMediaType = PdfCssMediaType.Screen,           // Respect on-screen CSS
        RenderDelay  = 100,                              // Wait 100 ms for JS/animations
        FallbackEncoding = "utf-8"                       // Handle non-ASCII correctly
    }
};

// 2. Render the HTML fragment
using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf");
// Program.cs — compatible with .NET 8 and newer
using IronPdf;

// Sample HTML fragment (could also be read from a file, Razor view, or CMS)
const string html = """
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>
""";

// 1. Create a renderer once and reuse it across conversions
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        PaperSize    = PdfPaperSize.A4,                  // ISO-standard paper size
        PaperOrientation = PdfPaperOrientation.Portrait,
        CssMediaType = PdfCssMediaType.Screen,           // Respect on-screen CSS
        RenderDelay  = 100,                              // Wait 100 ms for JS/animations
        FallbackEncoding = "utf-8"                       // Handle non-ASCII correctly
    }
};

// 2. Render the HTML fragment
using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf");
' Program.cs — compatible with .NET 8 and newer
Imports IronPdf

' Sample HTML fragment (could also be read from a file, Razor view, or CMS)
Private Const html As String = "<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""utf-8"">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>"

' 1. Create a renderer once and reuse it across conversions
Private renderer = New ChromePdfRenderer With {
	.RenderingOptions = {
		PaperSize = PdfPaperSize.A4,
		PaperOrientation = PdfPaperOrientation.Portrait,
		CssMediaType = PdfCssMediaType.Screen,
		RenderDelay = 100,
		FallbackEncoding = "utf-8"
	}
}

' 2. Render the HTML fragment
Private PdfDocument As using

' 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf")
$vbLabelText   $csharpLabel

Ce que montre le code

  • Chromium intégré — IronPDF intègre le moteur Chromium, garantissant la compatibilité HTML5, CSS3 et JavaScript avec les navigateurs modernes.
  • Dépendance unique — Une installation NuGet légère couvre Windows, Linux, Docker et Azure/AWS sans bibliothèques système supplémentaires.
  • Options de rendu — PaperSize, CssMediaType et RenderDelay reflètent les paramètres d'impression du navigateur afin que les PDF correspondent à la mise en page à l'écran.
  • Ciblage pérenne — L'interface API est identique for .NET 8, .NET 9 STS et le futur .NET 10, ce qui réduit la maintenance à long terme au minimum.
  • Hooks de post-traitement — PdfDocument expose des aides pour la fusion, la protection par mot de passe et les signatures numériques — chacune étant abordée plus loin dans ce guide.

Pour en savoir plus : consultez le tutoriel étape par étape sur la conversion de chaînes HTML en PDF et la documentation complète de l'API ChromePdfRenderer.

Comment exporter une vue ASP .NET Core MVC au format PDF ?

IronPDF affiche une vue Razor entièrement traitée ( .cshtml ) de la même manière qu'un navigateur le ferait et transmet le résultat sous forme de PdfDocument. Le workflow ci-dessous permet de garder la logique du contrôleur propre, ne nécessite aucun plugin de navigateur et fonctionne sur .NET 8 LTS, .NET 9 preview et la version .NET 10 prévue pour novembre 2025.

Exemple de contrôleur de bout en bout

// TicketsController.cs — .NET 8 LTS / MVC
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using YourApp.Models;           // TicketViewModel

public class TicketsController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public TicketsController()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions =
            {
                PaperSize        = PdfPaperSize.A5,            // Compact ticket size
                PaperOrientation = PdfPdfOrientation.Portrait,
                FitToPaperWidth  = true,
                CssMediaType     = PdfCssMediaType.Print,
                Margins = new PdfMargins(5, 10, 5, 10)         // mm
            }
        };
    }

    // GET /Tickets/Print/42
    public async Task<IActionResult> Print(int id)
    {
        TicketViewModel vm = await _service.GetTicketAsync(id);

        // 1. Render the Razor view to an HTML string
        string html  = await RazorTemplateEngine.RenderViewAsync(
                           HttpContext, "~/Views/Tickets/Print.cshtml", vm);

        // 2. Convert HTML → PDF
        using PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        // 3. Stream back as a file
        return File(pdf.BinaryData, "application/pdf",
                    $"ticket-{id}.pdf");
    }
}
// TicketsController.cs — .NET 8 LTS / MVC
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using YourApp.Models;           // TicketViewModel

public class TicketsController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public TicketsController()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions =
            {
                PaperSize        = PdfPaperSize.A5,            // Compact ticket size
                PaperOrientation = PdfPdfOrientation.Portrait,
                FitToPaperWidth  = true,
                CssMediaType     = PdfCssMediaType.Print,
                Margins = new PdfMargins(5, 10, 5, 10)         // mm
            }
        };
    }

    // GET /Tickets/Print/42
    public async Task<IActionResult> Print(int id)
    {
        TicketViewModel vm = await _service.GetTicketAsync(id);

        // 1. Render the Razor view to an HTML string
        string html  = await RazorTemplateEngine.RenderViewAsync(
                           HttpContext, "~/Views/Tickets/Print.cshtml", vm);

        // 2. Convert HTML → PDF
        using PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        // 3. Stream back as a file
        return File(pdf.BinaryData, "application/pdf",
                    $"ticket-{id}.pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports YourApp.Models ' TicketViewModel

Public Class TicketsController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer With {
            .RenderingOptions = New PdfRenderingOptions With {
                .PaperSize = PdfPaperSize.A5, ' Compact ticket size
                .PaperOrientation = PdfPdfOrientation.Portrait,
                .FitToPaperWidth = True,
                .CssMediaType = PdfCssMediaType.Print,
                .Margins = New PdfMargins(5, 10, 5, 10) ' mm
            }
        }
    End Sub

    ' GET /Tickets/Print/42
    Public Async Function Print(id As Integer) As Task(Of IActionResult)
        Dim vm As TicketViewModel = Await _service.GetTicketAsync(id)

        ' 1. Render the Razor view to an HTML string
        Dim html As String = Await RazorTemplateEngine.RenderViewAsync(
            HttpContext, "~/Views/Tickets/Print.cshtml", vm)

        ' 2. Convert HTML → PDF
        Using pdf As PdfDocument = _renderer.RenderHtmlAsPdf(html)
            ' 3. Stream back as a file
            Return File(pdf.BinaryData, "application/pdf", $"ticket-{id}.pdf")
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Ce que ce code illustre

  • Pas de fichiers temporaires : la vue Razor est rendue en mémoire, puis transmise directement à RenderHtmlAsPdf, ce qui évite les E/S disque et les conditions de concurrence dans le dossier temporaire.
  • Format de ticket — PaperSize = A5 et des marges étroites permettent d'obtenir des tickets compacts à imprimer chez soi.
  • Styles de print cohérents — CssMediaType = Print applique les mêmes règles CSS @media print que celles utilisées par les navigateurs.
  • Flux binaire — pdf.BinaryData transmet le document sans toucher au système de fichiers ; idéal pour les points de terminaison API et les fonctions Lambda.
  • Rendu réutilisable — ChromePdfRenderer est instancié une fois par contrôleur, puis réutilisé, ce qui minimise la charge liée à la création de processus.

PaperSize, PaperOrientation, FitToPaperWidth

Margins, Header, Footer, Watermark

Étape suivante : ajoutez le chiffrement, les signatures numériques ou fusionnez plusieurs tickets en un seul fichier. Consultez l'exemple de fusion et le guide pratique sur les signatures numériques.

Comment puis-je ajuster le format du papier, les marges, les en-têtes, les filigranes et les paramètres de sécurité avant le rendu ?

IronPDF expose un seul objet ChromePdfRenderOptions qui contrôle tous les aspects de la sortie — dimensions du papier, orientation, en-têtes et pieds de page, synchronisation JavaScript, filigranes, cryptage et signatures numériques — le tout sans plug-ins de navigateur supplémentaires.

Exemple de code — appliquer plusieurs options à la fois

// AdvancedOptions.cs — .NET 8 compatible
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure everything in one place
renderer.RenderingOptions = new ChromePdfRenderOptions
{
    // 1. Page layout
    PaperSize        = PdfPaperSize.A4,                     // ISO size
    PaperOrientation = PdfPdfOrientation.Portrait,
    Margins          = new PdfMargins { Top = 20, Bottom = 25, Left = 15, Right = 15 }, // mm

    // 2. Timing & media
    CssMediaType     = PdfCssMediaType.Print,               // Respect @media print
    EnableJavaScript = true,
    RenderDelay      = 200,                                 // Wait 200 ms for animations

    // 3. Headers & footers (HTML gives full design freedom)
    HtmlHeader       = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    HtmlFooter       = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    // 4. Watermark
    Watermark        = new HtmlStamp
    {
        HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        VerticalAlignment = VerticalAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center
    },

    // 5. Security
    SecurityOptions = new PdfSecurityOptions
    {
        OwnerPassword = "StrongOwnerPwd!",
        UserPassword  = "ReadOnly",
        AllowUserPrinting = false,
        AllowUserCopyPasteContent = false
    }
};

// Render any HTML
using PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>");

// Digitally sign with a PFX certificate (optional)
pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval");

// Save
pdf.SaveAs("advanced-options-demo.pdf");
// AdvancedOptions.cs — .NET 8 compatible
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure everything in one place
renderer.RenderingOptions = new ChromePdfRenderOptions
{
    // 1. Page layout
    PaperSize        = PdfPaperSize.A4,                     // ISO size
    PaperOrientation = PdfPdfOrientation.Portrait,
    Margins          = new PdfMargins { Top = 20, Bottom = 25, Left = 15, Right = 15 }, // mm

    // 2. Timing & media
    CssMediaType     = PdfCssMediaType.Print,               // Respect @media print
    EnableJavaScript = true,
    RenderDelay      = 200,                                 // Wait 200 ms for animations

    // 3. Headers & footers (HTML gives full design freedom)
    HtmlHeader       = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    HtmlFooter       = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    // 4. Watermark
    Watermark        = new HtmlStamp
    {
        HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        VerticalAlignment = VerticalAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center
    },

    // 5. Security
    SecurityOptions = new PdfSecurityOptions
    {
        OwnerPassword = "StrongOwnerPwd!",
        UserPassword  = "ReadOnly",
        AllowUserPrinting = false,
        AllowUserCopyPasteContent = false
    }
};

// Render any HTML
using PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>");

// Digitally sign with a PFX certificate (optional)
pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval");

// Save
pdf.SaveAs("advanced-options-demo.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Configure everything in one place
renderer.RenderingOptions = New ChromePdfRenderOptions With {
    ' 1. Page layout
    .PaperSize = PdfPaperSize.A4, ' ISO size
    .PaperOrientation = PdfPdfOrientation.Portrait,
    .Margins = New PdfMargins With {.Top = 20, .Bottom = 25, .Left = 15, .Right = 15}, ' mm

    ' 2. Timing & media
    .CssMediaType = PdfCssMediaType.Print, ' Respect @media print
    .EnableJavaScript = True,
    .RenderDelay = 200, ' Wait 200 ms for animations

    ' 3. Headers & footers (HTML gives full design freedom)
    .HtmlHeader = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    .HtmlFooter = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    ' 4. Watermark
    .Watermark = New HtmlStamp With {
        .HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        .VerticalAlignment = VerticalAlignment.Center,
        .HorizontalAlignment = HorizontalAlignment.Center
    },

    ' 5. Security
    .SecurityOptions = New PdfSecurityOptions With {
        .OwnerPassword = "StrongOwnerPwd!",
        .UserPassword = "ReadOnly",
        .AllowUserPrinting = False,
        .AllowUserCopyPasteContent = False
    }
}

' Render any HTML
Using pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>")
    ' Digitally sign with a PFX certificate (optional)
    pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval")

    ' Save
    pdf.SaveAs("advanced-options-demo.pdf")
End Using
$vbLabelText   $csharpLabel

Pourquoi ces options sont-elles importantes ?

  • PaperSize, Margins et CssMediaType reproduisent la boîte de dialogue d'impression d'un navigateur afin que la mise en page à l'écran et le PDF restent identiques sous Windows, Linux et Docker.
  • Les en-têtes et pieds de page HTML prennent en charge les tokens Razor, le CSS et le JavaScript, ce qui est pratique pour la numérotation dynamique des pages ou la personnalisation de la marque.
  • HtmlStamp permet de créer des filigranes de marque en une seule ligne avec un contrôle total du HTML et du CSS.
  • Les options de sécurité permettent un chiffrement 128 bits, des mots de passe propriétaire/utilisateur et des autorisations granulaires sans recourir à des outils tiers.
  • Les signatures numériques ajoutent un sceau cryptographique directement dans le code, garantissant ainsi l'authenticité juridique et la protection contre la falsification.
  • Les aides à l'extraction telles que ExtractAllText et ExtractAllImages inversent le processus lorsqu'une analyse est nécessaire.

Référence rapide — Paramètres courants

##

PaperSize, PaperOrientation, Margins, CssMediaType, RenderDelay

##

`HtmlHeader`, `HtmlFooter`, les balises dynamiques Razor, les jetons de numéros de page

##

`Watermark`, `HtmlStamp`, opacité, alignement

##

`SecurityOptions`, `SignAndStamp`, mots de passe propriétaire/utilisateur, scellage de certificats

Tâches suivantes : fusionner plusieurs fichiers PDF, extraire du texte et des images, et déployer sur Docker ou en mode serverless. Passez à la section sur le déploiement pour garantir la parité entre les plateformes.

Comment puis-je déployer du code de génération de PDF sur Docker sous Linux et Windows ?

IronPdf est fourni sous la forme d'un package NuGet autonome, ce qui facilite la conteneurisation d'une application ASP.NET Core (ou console) aussi bien sous Windows que sous Linux. La clé consiste à copier les binaires publiés dans une image d'exécution allégée et, sous Linux, à ajouter les deux bibliothèques natives requises par IronPDF (libnss3 et libatk1.0-0).

Dockerfile en plusieurs étapes (Ubuntu 22.04)

Veuillez noterPourquoi plusieurs étapes ? L'image SDK (étape 1) compile le projet ; l'image d'exécution finale (étape 2) reste légère — < 120 Mo — car les outils de compilation sont supprimés.

####### ---------- stage 1 ----------
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyPdfApp.csproj", "."]
RUN dotnet restore

COPY . .
RUN dotnet publish -c Release -o /app/publish

####### ---------- stage 2 ----------
FROM mcr.microsoft.com/dotnet/aspnet:8.0-jammy
######## Install two native libs required by Chromium
RUN apt-get update && \
    apt-get install -y --no-install-recommends libnss3 libatk1.0-0 && \
    rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyPdfApp.dll"]

Veuillez noterConteneurs Windows ? Remplacer la deuxième étape par mcr.microsoft.com/dotnet/aspnet:8.0-windowsservercore-ltsc2022—aucun paquet supplémentaire n'est nécessaire car les DLL Chromium sont incluses.

Script de validation de bout en bout

docker build -t pdf-demo .
docker run --rm -p 8080:80 pdf-demo
######### ↳ Navigate to http://localhost:8080/api/pdf?url=https://example.com
docker build -t pdf-demo .
docker run --rm -p 8080:80 pdf-demo
######### ↳ Navigate to http://localhost:8080/api/pdf?url=https://example.com
SHELL
  • L'action API appelle en interne ChromePdfRenderer.RenderUrlAsPdf, tout comme dans la section 2.
  • IronPDF lance son processus Chromium en mode sandbox à l'intérieur du conteneur — aucun serveur X n'est nécessaire car le rendu s'effectue en mode sans affichage.
  • L'empreinte mémoire reste inférieure à 200 Mo, même lors de rendus volumineux.

ConseilsConseil de dépannage : si les journaux du conteneur affichent une erreur " libnss3.so not found ", vérifiez que libnss3 et libatk1.0-0 sont bien présents. Les images Alpine ne sont pas prises en charge car la bibliothèque C musl ne dispose pas des symboles requis.

Ressources internes

Comment puis-je ouvrir, fusionner, ajouter un filigrane et extraire du contenu à partir de fichiers PDF existants dans .NET Core ?

IronPDF traite chaque fichier PDF — qu'il soit généré par IronPDF, Adobe® Acrobat ou des outils tiers — comme un objet PdfDocument de premier ordre pouvant être ouvert, modifié, sécurisé et réenregistré sans perte de qualité. La même interface API fonctionne aujourd'hui sur .NET 8 LTS et se compile sans modification sur la préversion de .NET 9 et la prochaine version de .NET 10.

Exemple unifié — ouvrir → fusionner → filigrane → extraire

// ManipulateExistingPdf.cs — .NET 8 LTS compatible
using IronPdf;
using System.Linq;

// Step 1: Open two existing files (password-protected PDFs are supported)
PdfDocument invoice  = PdfDocument.FromFile("invoice.pdf", "ReadOnly");   // open with user pwd
PdfDocument tAndCs   = PdfDocument.FromFile("terms.pdf");                 // no pwd required

// Step 2: Merge them (invoice pages first, then T&Cs)
PdfDocument mergedPdf = PdfDocument.Merge(invoice, tAndCs);               // 1-liner merge

// Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp(
    "<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);"
  + "width:100%;text-align:center;'>CONFIDENTIAL</div>",
    verticalAlignment   : VerticalAlignment.Center,
    horizontalAlignment : HorizontalAlignment.Center);

// Step 4: Extract all text and the first image for audit purposes
string fullText = mergedPdf.ExtractAllText();
var    image    = mergedPdf.ExtractAllImages().FirstOrDefault();

// Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf");
// ManipulateExistingPdf.cs — .NET 8 LTS compatible
using IronPdf;
using System.Linq;

// Step 1: Open two existing files (password-protected PDFs are supported)
PdfDocument invoice  = PdfDocument.FromFile("invoice.pdf", "ReadOnly");   // open with user pwd
PdfDocument tAndCs   = PdfDocument.FromFile("terms.pdf");                 // no pwd required

// Step 2: Merge them (invoice pages first, then T&Cs)
PdfDocument mergedPdf = PdfDocument.Merge(invoice, tAndCs);               // 1-liner merge

// Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp(
    "<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);"
  + "width:100%;text-align:center;'>CONFIDENTIAL</div>",
    verticalAlignment   : VerticalAlignment.Center,
    horizontalAlignment : HorizontalAlignment.Center);

// Step 4: Extract all text and the first image for audit purposes
string fullText = mergedPdf.ExtractAllText();
var    image    = mergedPdf.ExtractAllImages().FirstOrDefault();

// Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf");
' ManipulateExistingPdf.cs — .NET 8 LTS compatible
Imports IronPdf
Imports System.Linq

' Step 1: Open two existing files (password-protected PDFs are supported)
Private invoice As PdfDocument = PdfDocument.FromFile("invoice.pdf", "ReadOnly") ' open with user pwd
Private tAndCs As PdfDocument = PdfDocument.FromFile("terms.pdf") ' no pwd required

' Step 2: Merge them (invoice pages first, then T&Cs)
Private mergedPdf As PdfDocument = PdfDocument.Merge(invoice, tAndCs) ' 1-liner merge

' Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp("<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);" & "width:100%;text-align:center;'>CONFIDENTIAL</div>", verticalAlignment := VerticalAlignment.Center, horizontalAlignment := HorizontalAlignment.Center)

' Step 4: Extract all text and the first image for audit purposes
Dim fullText As String = mergedPdf.ExtractAllText()
Dim image = mergedPdf.ExtractAllImages().FirstOrDefault()

' Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf")
$vbLabelText   $csharpLabel

Pourquoi est-ce important ?

  • Ouvrir et fusionner – PdfDocument.FromFile charge tout fichier PDF conforme aux normes, y compris les fichiers cryptés, tandis que PdfDocument.Merge concatène un nombre arbitraire de documents en un seul appel.
  • Watermark – ApplyStamp (alias HtmlStamp) intègre des superpositions HTML/CSS entièrement stylisées (logo, QR ou texte en diagonale) sur les pages sélectionnées sans rastérisation.
  • Extraction de contenu – ExtractAllText et ExtractAllImages extraient du texte brut au format UTF-8 ou des flux d'images binaires à des fins d'archivage en aval ou pour des pipelines d'IA.
  • Prêt pour les signatures numériques : la même instance PdfDocument peut être scellée avec SignAndStamp, produisant des hachages conformes à la RFC 3161 et alignés sur les exigences de signature numérique de la norme ISO 32000-2.
  • Conformité aux normes ouvertes – IronPDF préserve la structure PDF d'origine (polices, calques, métadonnées XMP) afin que le fichier de sortie reste compatible avec Adobe® Reader et d'autres visionneuses conformes à la norme ISO 32000-1.
  • À l'épreuve du temps – L'API évite les assemblages d'interopérabilité et les appels Win32 GDI, ce qui permet au code de s'exécuter sans modification sous Windows, Linux, Docker et les futures SKU sans serveur .NET 10.

Besoin de diviser, de faire pivoter ou de supprimer des pages ? Consultez le tutoriel sur la modification au niveau de la page pour des opérations plus précises.

Comment crypter et signer numériquement des fichiers PDF dans .NET Core ?

IronPDF sécurise un document en deux étapes : un chiffrement basé sur l'AES (mots de passe utilisateur/propriétaire + autorisations granulaires) et des signatures numériques X.509 qui scellent le fichier à l'aide d'un hachage cryptographique. Les deux API résident sur le même objet PdfDocument, de sorte que le flux de travail est identique sur .NET 8 LTS aujourd'hui et se compile sans modification sur la préversion de .NET 9 et la prochaine version de .NET 10.

Exemple — appliquer un cryptage AES 256 bits, verrouiller les droits de PRINT et ajouter une signature visible

// SecureAndSign.cs — .NET 8 LTS compatible
using IronPdf;

// Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
PdfDocument pdf = PdfDocument.FromFile("financial-report.pdf");

// Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = new PdfSecuritySettings
{
    EncryptionAlgorithm   = PdfEncryptionAlgorithm.AES256Bit,
    OwnerPassword         = "IronAdmin!2025",
    UserPassword          = "ReadOnly",
    AllowUserPrinting     = PdfPrintSecurity.Disabled,
    AllowUserCopyPasteContent = false,
    AllowUserAnnotations  = false
};

// Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(
    certificatePath : "./certs/ironsoftware.pfx",
    authority       : "Iron Software Ltd.",
    location        : "Chicago, IL",
    reason          : "Final approval"
);

// Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf");
// SecureAndSign.cs — .NET 8 LTS compatible
using IronPdf;

// Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
PdfDocument pdf = PdfDocument.FromFile("financial-report.pdf");

// Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = new PdfSecuritySettings
{
    EncryptionAlgorithm   = PdfEncryptionAlgorithm.AES256Bit,
    OwnerPassword         = "IronAdmin!2025",
    UserPassword          = "ReadOnly",
    AllowUserPrinting     = PdfPrintSecurity.Disabled,
    AllowUserCopyPasteContent = false,
    AllowUserAnnotations  = false
};

// Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(
    certificatePath : "./certs/ironsoftware.pfx",
    authority       : "Iron Software Ltd.",
    location        : "Chicago, IL",
    reason          : "Final approval"
);

// Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf");
' SecureAndSign.cs — .NET 8 LTS compatible
Imports IronPdf

' Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
Private pdf As PdfDocument = PdfDocument.FromFile("financial-report.pdf")

' Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = New PdfSecuritySettings With {
	.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256Bit,
	.OwnerPassword = "IronAdmin!2025",
	.UserPassword = "ReadOnly",
	.AllowUserPrinting = PdfPrintSecurity.Disabled,
	.AllowUserCopyPasteContent = False,
	.AllowUserAnnotations = False
}

' Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(certificatePath := "./certs/ironsoftware.pfx", authority := "Iron Software Ltd.", location := "Chicago, IL", reason := "Final approval")

' Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf")
$vbLabelText   $csharpLabel

En coulisses

  • Chiffrement AES-256 — IronPDF encapsule la charge utile à l'aide de clés AES approuvées par le NIST, empêchant ainsi toute ouverture, impression ou copie-collage non autorisés.
  • Granularité des autorisations — des propriétés telles que AllowUserPrinting et AllowUserFormData permettent d'activer ou de désactiver les droits par action ; Un mot de passe propriétaire est requis pour que toute restriction prenne effet.
  • Signatures numériques — SignAndStamp intègre un horodatage RFC 3161 et une chaîne de certificats, créant ainsi des hachages inviolables reconnus par Adobe® Acrobat et d'autres visionneuses conformes à la norme ISO 32000-2.
  • API tout-en-un : le chiffrement et la signature modifient la même instance PdfDocument, ce qui évite les passages multiples entre fichiers et préserve les polices, les calques et les métadonnées internes.

ConseilsConseil de dépannage : si Adobe Reader signale une " signature non valide ", assurez-vous que le fichier PFX contient un certificat racine de confiance et que les chaînes location sont conformes à la norme ASCII.

Paramètres de sécurité de base

##

`PdfSecuritySettings` → `OwnerPassword`, `UserPassword`, `EncryptionAlgorithm`, `AllowUserPrinting`

##

`PdfDocument.SignAndStamp` — Chemin d'accès PFX, autorité, emplacement, motif, horodatage

Ressources internes pour approfondir le sujet

Comment optimiser et faire évoluer les performances de la conversion HTML vers PDF dans .NET Core ?

Le moteur Chrome d'IronPDF affiche déjà la plupart des pages en moins d'une seconde sur du matériel moderne, mais le débit peut être multiplié en regroupant les rendus, en activant le multithreading et en réduisant la charge de Headless Chrome. Les conseils ci-dessous s'appliquent de la même manière à toutes les versions .NET.

1. Rendu par lots sur un pool de threads d'arrière-plan

// BatchRender.cs — Thread-safe on .NET 8+
using IronPdf;
using System.Threading.Tasks;

var htmlSources = Directory.GetFiles("./html", "*.html");
var renderer    = new ChromePdfRenderer();                 // reuse 1 instance

Parallel.ForEach(htmlSources, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
    string html = File.ReadAllText(file);
    using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(Path.ChangeExtension(file, ".pdf"));
});
// BatchRender.cs — Thread-safe on .NET 8+
using IronPdf;
using System.Threading.Tasks;

var htmlSources = Directory.GetFiles("./html", "*.html");
var renderer    = new ChromePdfRenderer();                 // reuse 1 instance

Parallel.ForEach(htmlSources, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
    string html = File.ReadAllText(file);
    using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(Path.ChangeExtension(file, ".pdf"));
});
' BatchRender.cs — Thread-safe on .NET 8+
Imports IronPdf
Imports System.Threading.Tasks

Private htmlSources = Directory.GetFiles("./html", "*.html")
Private renderer = New ChromePdfRenderer() ' reuse 1 instance

Parallel.ForEach(htmlSources, New ParallelOptions With {.MaxDegreeOfParallelism = Environment.ProcessorCount}, Sub(file)
	Dim html As String = File.ReadAllText(file)
	Using pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
		pdf.SaveAs(Path.ChangeExtension(file, ".pdf"))
	End Using
End Sub)
$vbLabelText   $csharpLabel

2. Réduire les coûts de démarrage de Headless Chrome

IronPDF fournit sa propre version de Chromium, mais chaque rendu entraîne un léger temps de démarrage. Le pooling est utile, et les conteneurs Linux doivent inclure deux bibliothèques natives :

RUN apt-get update && \
    apt-get install -y --no-install-recommends libnss3 libatk1.0-0

L'absence de l'une ou l'autre de ces bibliothèques se traduit par une erreur libnss3.so not found dans les journaux Docker.

Les indicateurs Chrome recommandés (appliqués automatiquement par IronPDF) incluent --disable-gpu et --no-sandbox pour réduire les problèmes de mémoire et d'utilisateur root dans les conteneurs.

3. Attendre le JavaScript tardif avec RenderDelay ou WaitFor

Les pages qui animent des compteurs ou récupèrent des données après DOMContentLoaded peuvent nécessiter un court délai :

renderer.RenderingOptions.RenderDelay = 200;        // ms
// OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
renderer.RenderingOptions.RenderDelay = 200;        // ms
// OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
renderer.RenderingOptions.RenderDelay = 200 ' ms
' OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
$vbLabelText   $csharpLabel

Consultez le tutoriel WaitFor dédié aux promesses personnalisées et au sondage DOM.

4. Activer la journalisation de débogage pour une requête

renderer.LoggingOptions.DebugMode        = true;
renderer.LoggingOptions.LogsToConsole    = true;
renderer.LoggingOptions.LogFilePath      = "./logs/ironpdf-debug.log";
renderer.LoggingOptions.DebugMode        = true;
renderer.LoggingOptions.LogsToConsole    = true;
renderer.LoggingOptions.LogFilePath      = "./logs/ironpdf-debug.log";
renderer.LoggingOptions.DebugMode = True
renderer.LoggingOptions.LogsToConsole = True
renderer.LoggingOptions.LogFilePath = "./logs/ironpdf-debug.log"
$vbLabelText   $csharpLabel

Les traces Live DevTools mettent en évidence les polices manquantes, les images 404 et les événements de synchronisation sans avoir à recompiler le code.

5. Réutiliser des modèles PDF au lieu de les réafficher

Pour les séries de factures, créez un modèle PDF avec des espaces réservés tels que [[name]] et effectuez un remplacement de texte plutôt que de reconstruire du code HTML complexe. Elle est 10 fois plus rapide et consomme peu de mémoire.

Liste de contrôle pour une mise au point rapide

##

`Parallel.ForEach`, `async/await`, réutiliser un seul `ChromePdfRenderer`

##

Utilisez `aspnet:8.0-jammy`; install `libnss3` + `libatk1.0-0`; drapeaux `--no-sandbox`, `--disable-gpu`

##

`RenderDelay`, `WaitFor()`, consigner la chronologie DevTools pour les hydratations SPA lentes

Lectures complémentaires

Où puis-je télécharger une version d'essai gratuite, choisir une licence et bénéficier d'une assistance par des experts ? {#anchor-10-resources}

Une clé d'essai de 30 jours est émise instantanément à partir du formulaire Commencer l'essai gratuit et débloque toutes les fonctionnalités — y compris la conversion HTML vers PDF, les signatures numériques et le chiffrement — sans filigrane.

Après avoir évalué la bibliothèque, choisissez une licence perpétuelle de développement, de déploiement ou Enterprise ; Chaque formule comprend des mises à jour mineures gratuites, des droits d'utilisation en développement, en préproduction et en production, ainsi qu'une garantie de remboursement de 30 jours. L'application de la clé se fait en une seule ligne de code (IronPdf.License.LicenseKey = "YOUR-KEY";) et peut être automatisée dans les pipelines CI/CD.

Une documentation complète (guides de démarrage rapide, référence API et vidéos tutorielles) est disponible sur le portail de documentation et est mise à jour à chaque nouvelle version de .NET.

Les questions techniques reçoivent une réponse dans un délai d'un jour ouvré via le chat en direct, par e-mail ou par téléphone de la part de l'équipe d'assistance basée à Chicago.

Les FAQ sur l'optimisation des performances et le déploiement sont regroupées dans le Centre d'assistance aux performances.

Liens rapides

Ressource URL Pourquoi est-ce important ?
Obtenez une clé d'essai de 30 jours https://ironpdf.com/demos/ Débloque toutes les fonctionnalités sans filigranes
Licences et tarifs https://ironpdf.com/licensing/ Formules à vie ou par abonnement ; Iron Suite regroupe 10 bibliothèques
Référence API https://ironpdf.com/object-reference/api/ Documentation complète des classes, par exemple ChromePdfRenderer
Portail de documentation https://ironpdf.com/docs/ Guides, tutoriels, exemples de projets
Assistance à la performance https://ironpdf.com/troubleshooting/ironpdf-performance-assistance/ Conseils d'optimisation et de mise à l'échelle
Contacter le support https://ironsoftware.com/contact-us/ Assistance par chat en direct, e-mail et téléphone

Prochaines étapes

  1. Clonez le dépôt d'exemple qui présente toutes les fonctionnalités principales, du rendu des vues MVC au chiffrement AES-256.
  2. Intégrez la clé d'essai dans une solution existante et exécutez les tests unitaires pour valider la compatibilité multiplateforme.
  3. Réservez une démonstration en direct avec l'équipe d'ingénieurs pour obtenir des recommandations spécifiques à votre projet.

Grâce à ces ressources, toute équipe .NET peut livrer des PDF d'une qualité parfaite en production — sur site, dans Docker ou en mode sans serveur — en un seul sprint.

Questions Fréquemment Posées

Comment puis-je convertir du HTML en PDF dans .NET Core ?

Vous pouvez convertir du HTML en PDF dans .NET Core en utilisant la bibliothèque IronPDF. Tout d'abord, installez le package NuGet IronPDF, puis créez une instance de ChromePdfRenderer. Utilisez la méthode RenderHtmlAsPdf pour convertir les chaînes HTML en PDFs.

Comment convertir une URL de site web en document PDF ?

Pour convertir une URL de site web en document PDF, installez le package NuGet IronPDF, créez une instance de ChromePdfRenderer, et utilisez la méthode RenderUrlAsPdf pour rendre l'URL en PDF. Le résultat peut être enregistré en utilisant la méthode SaveAs.

Quelle est la meilleure façon de convertir des vues Razor en PDFs ?

La meilleure façon de convertir des vues Razor en PDFs est d'utiliser IronPDF. D'abord, rendez la vue Razor en une chaîne HTML, puis passez cette chaîne à la méthode RenderHtmlAsPdf pour créer un document PDF.

Comment puis-je améliorer la sécurité de mes documents PDF ?

Améliorez la sécurité des PDFs avec IronPDF en appliquant le chiffrement AES-256, en définissant des mots de passe et en contrôlant les autorisations des utilisateurs. Configurez ces paramètres via la propriété SecuritySettings pour restreindre des actions telles que l'impression et la modification.

Quelles options sont disponibles pour personnaliser le rendu des PDF ?

IronPDF fournit diverses options de rendu via la classe ChromePdfRenderOptions, y compris la définition de la taille du papier, de l'orientation, des marges, et l'application des types de médias CSS. Vous pouvez également ajouter des en-têtes, pieds de page, et filigranes pour une sortie de document personnalisée.

Comment déployer une application de génération de PDF dans un conteneur Docker ?

Pour déployer une application de génération de PDF dans un conteneur Docker, configurez les dépendances Linux dans votre Dockerfile et définissez les permissions de l'utilisateur. Utilisez IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig pour la gestion automatique des dépendances.

Comment puis-je ajouter des filigranes à un PDF en utilisant C# ?

Vous pouvez ajouter des filigranes aux PDFs avec IronPDF en utilisant la propriété Watermark avec des objets HtmlStamp. Pour des options avancées, la classe HtmlStamper permet des positionnements et effets de transparence personnalisés.

Puis-je ajouter des signatures numériques aux documents PDF ?

Oui, vous pouvez ajouter des signatures numériques aux PDFs en utilisant la classe PdfSignature d'IronPDF. Utilisez la méthode Sign sur un PdfDocument et fournissez un fichier de certificat pour assurer l'intégrité et l'authenticité du document.

Comment puis-je optimiser les performances de génération de PDF dans .NET Core ?

Optimisez les performances de génération de PDF en réutilisant une instance de ChromePdfRenderer thread-safe, en activant le multi-threading et en éliminant les drapeaux de démarrage headless-Chrome inutiles. Ces pratiques contribuent à améliorer l'efficacité de votre application.

L'exemple HTML vers PDF en .NET Core de ce tutoriel fonctionne-t-il également avec .NET 10 ?

Oui. IronPDF est entièrement compatible avec .NET 10, vous pouvez donc utiliser l'exemple ChromePdfRenderer HTML-vers-PDF de ce tutoriel dans des projets .NET 10 sans modifier le code principal. La principale différence est que vous ciblez .NET 10 lors de la création du projet, puis installez le dernier package IronPDF depuis NuGet pour générer des PDFs parfaits à partir de HTML, de vues Razor ou d'URLs.

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

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, ...

Lire la suite
Revu par
Jeff Fritz
Jeffrey T. Fritz
Responsable principal du programme - Équipe de la communauté .NET
Jeff est également responsable principal du programme pour les équipes .NET et Visual Studio. Il est le producteur exécutif de la série de conférences virtuelles .NET Conf et anime 'Fritz and Friends', une diffusion en direct pour développeurs qui est diffusée deux fois par semaine où il parle de technologie et écrit du code avec les téléspectateurs. Jeff écrit des ateliers, des présentations et prévoit du contenu pour les plus grands événements de développement Microsoft, y compris Microsoft Build, Microsoft Ignite, .NET Conf et le sommet Microsoft MVP
Prêt à commencer?
Nuget Téléchargements 19,014,616 | Version : 2026.5 just released
Still Scrolling Icon

Vous faites encore défiler ?

Vous voulez une preuve rapidement ? PM > Install-Package IronPdf
exécuter un échantillon Regardez votre code HTML se transformer en PDF.