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 avec .NET Core en C# grâce à 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

Générer des PDF de haute fidélité directement à partir du HTML est une exigence courante dans les applications modernes .NET - rapports, factures et billets nécessitent tous une sortie pixel-perfect qui correspond à l'interface utilisateur du web. IronPDF simplifie ce flux de travail en exposant une API unique en C# pour rendre le HTML, les vues Razor et les sites web complets en documents PDF conformes aux normes. À la fin de ce guide, un développeur pourra convertir des URL, du HTML brut ou des vues MVC dans un projet ASP.NET Core, et déployer le même code sous Windows, Linux, Docker ou des environnements serverless.

ConseilsPour les problèmes de mise en page, IronPDF livre un débogueur Chrome sans tête qui aide à diagnostiquer les bizarreries CSS, JavaScript et media-query avant que le PDF ne soit rendu. Consultez le guide dédié HTML à PDF pixel-perfect pour des techniques approfondies.

Démarrage rapide : Créer un PDF à partir de HTML avec .NET Core

Convertissez sans effort le HTML en PDF dans .NET Core en utilisant la bibliothèque IronPDF. Ce guide fournit un exemple simple pour vous permettre de commencer rapidement en rendant le contenu HTML dans un PDF de haute qualité avec un minimum de code. Idéal pour les développeurs cherchant à intégrer la création de PDF dans leurs applications avec facilité.

  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

Flux de travail minimal (5 étapes)

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

Liste de vérification rapide

  1. Installer – Install-Package IronPdf
  2. Générer une URL – ChromePdfRenderer.RenderUrlAsPdf()
  3. Générer du HTML brut – ChromePdfRenderer.RenderHtmlAsPdf()
  4. Exporter une vue Razor – ChromePdfRenderer.RenderHtmlAsPdfAsync()
  5. Optimiser le résultat – tirer parti de ChromePdfRenderer.RenderingOptions

Ce que ce tutoriel couvre

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

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

Installer la bibliothèque est une simple commande dans tout projet .NET 8 et reste compatible avec la préversion de .NET 9 et la prochaine version .NET 10. Utilisez la console du gestionnaire de packages de NuGet et le gestionnaire de packages résoudra automatiquement chaque dépendance pour Windows, Linux, Docker et les cibles serverless.

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

Veuillez noter Besoin de l'interface de ligne de commande ? La même commande fonctionne avec dotnet add package IronPdf dans le dossier de votre projet.

Une fois installé, confirmez que tout est en place 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 fonctionne

  • ChromePdfRenderer lance une instance Chromium sandboxée en arrière-plan - aucune installation Chrome séparée 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'assistance pour la fusion, la protection par mot de passe ou la signature numérique de la sortie - des capacités couvertes 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 configuration avancée de NuGet. Les conseils CI/CD internes pour Docker et les clusters K8s sont abordés dans les meilleures pratiques de déploiement Docker.

Comment un service .NET Core peut-il convertir une URL de site web en PDF ?

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

Exemple pas à pas

// 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 ça fonctionne

  • ChromePdfRenderer lance une instance Chromium sandboxée - aucune dépendance système Chrome, ce qui permet de garder les images Docker légères.
  • RenderUrlAsPdf attend que le DOM et JavaScript aient terminé avant de prendre un instantané, afin que les applications monopages s'affichent correctement.
  • Définir CssMediaType sur Imprimer 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 capacités couvertes dans les sections suivantes.

Conseils Débogage au pixel près : activez renderer.LoggingOptions.DebugMode = true et suivez le guide de débogage de Chrome sans interface graphique pour inspecter les outils de développement en direct pendant le rendu.

Ressources connexes

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

Le passage d'une chaîne HTML (ou du balisage rendu d'une vue Razor ) à ChromePdfRenderer.RenderHtmlAsPdf produit instantanément un PDF conforme aux normes. La méthode lance le moteur Chromium intégré d'IronPDF, donc aucune installation de navigateur externe ou dépendance WebView n'est requise. Le même code illustré ci-dessous se compile sur .NET 8 LTS aujourd'hui et reste compatible avec .NET 9 et la version .NET 10 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 le code démontre

  • Chromium intégré -- IronPDF regroupe le moteur Chromium, garantissant la parité 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 aux mises en page à l'écran.
  • Ciblage à l'épreuve du futur -- L'API est la même sur .NET 8, .NET 9 STS, et la prochaine version .NET 10, donc l'entretien à long terme est minimal.
  • Les hooks de post-traitement -- PdfDocument exposent des assistants pour la fusion, la protection par mot de passe et les signatures numériques — chacun étant traité plus loin dans ce guide.

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

Comment une vue ASP .NET Core MVC peut-elle être exportée en PDF ?

IronPDF affiche une vue Razor entièrement traitée ( .cshtml ) de la même manière qu'un navigateur et diffuse le résultat sous forme de PdfDocument. Le flux de travail ci-dessous garde 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 en 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 , évitant les E/S disque et les conditions de concurrence du dossier temporaire .
  • Format de billet -- PaperSize = A5 et marges étroites permettent de rendre les billets à imprimer à domicile compacts.
  • Styles d'impression cohérents -- CssMediaType = Print applique les mêmes règles CSS que les navigateurs.
  • Flux binaire -- pdf.BinaryData diffuse 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é, minimisant la surcharge de génération de processus.
##

`PaperSize` , `PaperOrientation` , `FitToPaperWidth`

##

`Margines`, `Header`, `Footer`, `Watermark`

Prochaines étapes : ajouter le chiffrement, les signatures numériques ou fusionner plusieurs billets en un seul fichier. Voir l' exemple de fusion et le guide des signatures numériques.

Comment ajuster la taille du papier, marges, en-têtes, filigranes et 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, chiffrement et signatures numériques, le tout sans plugins 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 comptent

  • PaperSize, Margins et CssMediaType reflètent la boîte de dialogue d'impression d'un navigateur afin que les mises en page à l'écran et le PDF restent identiques sous Windows, Linux et Docker.
  • En-têtes et pieds de page HTML supportent les jetons Razor, le CSS et le JavaScript – pratique pour les numéros de page dynamiques ou le branding.
  • HtmlStamp permet de créer des filigranes de marque en une seule ligne avec un contrôle HTML + CSS complet.
  • Options de sécurité activent le cryptage 128 bits, les mots de passe propriétaires/utilisateurs et des autorisations granulaires sans outils tiers.
  • Signatures numériques ajoutent un sceau cryptographique directement dans le code, maintenant l'authenticité légale et la preuve de falsification.
  • Les fonctions d'extraction telles que ExtractAllText et ExtractAllImages inversent le processus lorsque l'analyse est nécessaire.

Référence rapide — Paramètres populaires

##

`PaperSize` , `PaperOrientation` , `Margins` , `CssMediaType` , `RenderDelay`

##

`HtmlHeader`, `HtmlFooter`, placeholders dynamiques de Razor, jetons de numéro de page

##

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

##

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

Prochaines tâches : fusionner plusieurs PDFs, extraire du texte et des images, et déployer sur Docker ou sans serveur. Continuez vers la section de déploiement pour garantir la parité multiplateforme.

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

IronPDF est distribué sous la forme d'un package NuGet autonome, rendant la conteneurisation d'une application ASP.NET Core (ou console) simple sur Windows et Linux. La clé est de copier les binaires publiés dans une image d'exécution légère et, sous Linux, d'ajouter les deux bibliothèques natives requises par IronPDF (libnss3 et libatk1.0-0).

Dockerfile multi-étapes (Ubuntu 22.04)

Veuillez noterPourquoi multi-étape ? 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 build 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 noter Conteneurs Windows ? Remplacez la deuxième étape par mcr.microsoft.com/dotnet/aspnet:8.0-windowsservercore-ltsc2022—aucun package 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 comme dans la section 2.
  • Comment faire – Exécuter IronPDF sur Azure App Service Linux
  • L'empreinte mémoire reste inférieure à 200 Mo même lors de grands rendus.

Conseils Conseil de dépannage : Si les journaux du conteneur affichent une erreur " libnss3.so introuvable " , vérifiez que libnss3 et libatk1.0-0 sont présents. IronPDF traite chaque PDF — qu'il soit généré par IronPDF, Adobe® Acrobat ou des outils tiers — comme un objet PdfDocument de premier ordre qui peut être ouvert, édité, sécurisé et ré-enregistré sans perte de qualité.

Ressources internes

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

IronPDF traite chaque PDF, qu'il soit généré par IronPDF, Adobe® Acrobat ou des outils tiers, comme un objet de première classe qui peut être ouvert, modifié, sécurisé et réenregistré sans perte de qualité. La même surface API fonctionne aujourd'hui sur .NET 8 LTS et se compile sans changement sur .NET 9 preview et la prochaine version .NET 10.

Échantillon unifié — ouvrir → fusionner → ajouter un 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 cela compte

  • Ouvrir et fusionner – PdfDocument.FromFile charge tout PDF conforme aux normes, y compris les fichiers chiffrés, tandis que PdfDocument.Merge concatène un nombre arbitraire de documents en un seul appel.
  • Filigrane – ApplyStamp (alias HtmlStamp) intègre des superpositions HTML/CSS entièrement stylisées - logo, code QR ou texte diagonal - sur les pages sélectionnées sans rastérisation.
  • Extraction de contenu – ExtractAllText et ExtractAllImages extraient des flux de texte UTF-8 bruts ou des flux d'images binaires pour l'archivage en aval ou les pipelines d'IA.
  • Signatures numériques prêtes – la même instance PdfDocument peut être scellée avec SignAndStamp, produisant des hachages conformes à la RFC 3161 alignés sur les exigences de signature numérique ISO 32000-2 .
  • Conformité aux normes ouvertes – IronPDF préserve la structure PDF originale (polices, calques, métadonnées XMP) afin que la sortie reste compatible avec Adobe® Reader et les autres visionneuses ISO 32000-1.
  • Préparation pour l'avenir – L'API évite les assemblies interop et les appels GDI Win32, de sorte que le code s'exécute inchangé sur Windows, Linux, Docker, et les futures versions serverless .NET 10.

Besoin de diviser, faire pivoter ou supprimer des pages ? Consultez le tutoriel de modification au niveau des pages pour des opérations granulaires.

Comment les PDF peuvent-ils être cryptés et signés numériquement dans .NET Core ?

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

Exemple — appliquer AES 256 bits, verrouiller les droits d'impression 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
  • API unique -- le chiffrement et la signature modifient la même instance PdfDocument, évitant plusieurs passages de fichier et préservant les polices internes, les couches et les métadonnées.

ConseilsConseil de dépannage : si Adobe Reader signale " signature invalide ", assurez-vous que le PFX contient un certificat racine de confiance et que les chaînes reason / location sont propres ASCII.

  • Granularité des permissions -- des propriétés telles que AllowUserPrinting et AllowUserFormData basculent 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 des hachages inviolables reconnus par Adobe® Acrobat et d'autres visionneuses ISO 32000-2.
  • API unique -- le chiffrement et la signature modifient la même instance PdfDocument, évitant ainsi plusieurs passages de fichiers et préservant les polices internes, les calques et les métadonnées.

Conseils Conseil de dépannage : si Adobe Reader signale une " signature invalide ", assurez-vous que le fichier PFX contient un certificat racine de confiance et que les chaînes location sont au format ASCII correct.

Paramètres de sécurité principaux

##

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

##

`PdfDocument.SignAndStamp` - Chemin PFX, autorité, emplacement, raison, horodatage

Ressources internes pour des plongées plus profondes

Comment optimiser et mettre à l'échelle les performances HTML vers PDF dans .NET Core ?

Le moteur Chromium d'IronPDF rend déjà la plupart des pages en < 1 s sur du matériel moderne, mais le débit peut être multiplié par l'optimisation des rendus par lots, l'activation du multi-threading, et la réduction des surcharges de headless-Chrome. Les conseils ci-dessous s'appliquent également à toutes les versions .NET.

1. Rendus par lots sur un pool de threads en 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 le coût de démarrage de Chrome sans interface graphique

IronPDF distribue sa propre version Chromium, mais chaque rendu entraîne un petit surcoût initial. La mise en commun des ressources 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

Missing either library manifests as a libnss3.so not found error in Docker logs.

Recommended Chrome flags (automatically applied by IronPDF) include --disable-gpu and --no-sandbox to reduce memory and root-user issues in containers.

3. Attendez la fin du JavaScript 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

Voir le tutoriel WaitFor pour des promesses personnalisées et le sondage de DOM.

4. Activez la journalisation de débogage pour une demande

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 exposent les polices manquantes, les images en 404 et les événements de timing sans recompilation du code.

5. Réutilisez les PDF modèles au lieu de les re-rendre

Pour l'émission des factures, créez un modèle PDF avec des espaces réservés comme [[name]] et effectuez un remplacement de texte au lieu de reconstruire un code HTML complexe. C'est 10× plus rapide et léger en mémoire.

Liste de vérification d'ajustement rapide

##

`Parallel.ForEach`, `async/await`, réutilisation d'un seul `ChromePdfRenderer`

##

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

##

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

Lectures complémentaires

Où puis-je télécharger un essai gratuit, choisir une licence et trouver un support expert ? {#anchor-10-resources}

Une clé d'essai de 30 jours est émise instantanément à partir du formulaire Démarrer un essai gratuit et débloque chaque fonctionnalité, y compris HTML-à-PDF, signatures numériques et cryptage, sans filigrane.

Après avoir évalué la bibliothèque, choisissez une licence développeur, de déploiement ou entreprise perpétuelle ; chaque plan inclut des mises à jour mineures gratuites, des droits d'utilisation en dev/staging/production, et 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.

La documentation complète — guides de démarrage rapide, référence API, et tutoriels vidéo — est disponible au portail des docs et est mise à jour pour chaque version de .NET.

Les questions d'ingénierie reçoivent des réponses sous un jour ouvrable via chat en direct, e-mail, ou téléphone avec l'équipe de support basée à Chicago.

Les questions fréquentes sur l'optimisation des performances et le déploiement sont agrégées dans le Centre d'assistance à la performance.

Liens rapides

Ressource URL Pourquoi cela est important
Obtenez une clé d'essai de 30 jours https://ironpdf.com/demos/ Débloque chaque fonctionnalité sans filigranes
Licences & tarification https://ironpdf.com/licensing/ Plans perpétuels ou par abonnement; Iron Suite regroupe 10 bibliothèques
Référence API https://ironpdf.com/object-reference/api/ Documentation complète du cours, par exemple ChromePdfRenderer
Portail des docs https://ironpdf.com/docs/ Guides, tutoriels, projets d'exemple
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/ Chat en direct, courrier électronique, assistance téléphonique

Prochaines étapes

  1. Clonez le repo d'exemple qui démontre chaque fonctionnalité majeure, de la restitution du MVC au cryptage AES-256.
  2. Brancher la clé d'essai dans une solution existante et exécutez les tests unitaires pour valider la compatibilité multiplateforme.
  3. Réservez une démo en direct avec l'équipe d'ingénierie pour des recommandations spécifiques au projet.

Avec ces ressources en main, toute équipe .NET peut expédier des PDF parfaits en production — sur site, dans Docker ou sans serveur — en une seule itération.

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 en using 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 en using 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 18,560,885 | Version : 2026.4 vient de sortir
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.