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

Convertir 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

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 fournit un débogueur headless-Chrome qui aide à diagnostiquer les bizarreries CSS, JavaScript et media-query avant que le PDF ne soit rendu. Consultez le guide pixel-perfect HTML-to-PDF pour des techniques approfondies.

en-tête rapide :2(Démarrage rapide : Créer un PDF à partir de HTML dans .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é.

Nuget IconCommencez dès maintenant à créer des PDF avec NuGet :

  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 grâce à 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. Rendre une URL – ChromePdfRenderer.RenderUrlAsPdf()
  3. Rendre du HTML brut – ChromePdfRenderer.RenderHtmlAsPdf()
  4. Exporter une vue Razor – ChromePdfRenderer.RenderHtmlAsPdfAsync()
  5. Ajuster la sortie – utiliser 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

Commencer avec IronPDF

Commencez à utiliser IronPDF dans votre projet aujourd'hui avec un essai gratuit.

Première étape :
green arrow pointer

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 noterNeutral CLI? 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 quelleURLpublique :

// 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 isolée en arrière-plan - aucune installation distincte de Chrome n'est requise.
  • RenderUrlAsPdf capture le DOM entièrement rendu, y compris le contenu piloté par JavaScript, les demandes CSS media queries et les polices.
  • Le PdfDocument résultant expose des méthodes d'assistance pour fusionner, protéger par mot de passe, ou signer numériquement la sortie - capacités couvertes plus tard 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 uneURLde site web en PDF ?

Un simple appel à RenderUrlAsPdf suffit : passez n'importe quelleURLpubliquement accessible et IronPDF retourne un PDF pleinement 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 isolée - pas de dépendance systémique à Chrome, ce qui maintient les images Docker minces.
  • RenderUrlAsPdf attend la fin du DOM et du JavaScript avant de prendre un instantané, afin que les applications monopages se rendent correctement.
  • Définir CssMediaType sur Print informe le moteur d'utiliser des règles spécifiques à l'impression, correspondant à la sortie Save as PDF d'un navigateur.
  • Le PdfDocument résultant peut être chiffré, signé numériquement, fusionné ou transformé en image - capacités couvertes dans les sections ultérieures.

[{t :(Débogage parfait de Pixel: activez renderer.LoggingOptions.DebugMode = true et suivez le headless-Chrome debug guide pour inspecter en direct les DevTools pendant le rendu.)}]

Ressources connexes

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

Passer une chaîne HTML — ou le balisage d'une vue Razor rendue — à 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 pour que les PDFs 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.
  • Hooks de post-traitement -- PdfDocument expose des aides pour la fusion, la protection par mot de passe et signatures numériques - chacun de ces sujets étant abordé plus loin dans ce guide.

Lecture supplémentaire : voir le tutoriel HTML-string-to-PDF étape par étape et la documentation API complète de ChromePdfRenderer.

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

IronPDF rend une vue Razor entièrement traitée ( .cshtml ) de la même manière qu'un navigateur le ferait 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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Ce que ce code illustre

  • Pas de fichiers temporaires -- la vue Razor est rendue en mémoire, puis transmise directement à RenderHtmlAsPdf, évitant la lecture/écriture sur disque et les conditions de course du dossier temporaire.
  • Sortie de taille de billet -- PaperSize = A5 et des marges étroites gardent les billets à imprimer à domicile compacts.
  • Styles d'impression cohérents -- CssMediaType = Print applique les mêmes règles CSS @media print que les navigateurs utilisent.
  • Diffusion 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.
  • Renderer réutilisable -- ChromePdfRenderer est instancié une fois par contrôleur, puis réutilisé, minimisant les frais généraux de spawn 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 chaque aspect de la sortie : dimensions du papier, orientation, en-têtes et pieds de page, timing JavaScript, filigranes, cryptage 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");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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 sur 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 une marque d'eau personnalisée avec un contrôle complet HTML + CSS en une seule ligne.
  • 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 aides à l'extraction telles que ExtractAllText et ExtractAllImages inversent le processus lorsque l'analyse est requise.

Référence rapide — Paramètres populaires

class="accordion-item"> ## id="layHead">
data-bs-parent="#advRenderAcc">
class="accordion-body">

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

PaperSize, PaperOrientation, Margins, CssMediaType, RenderDelay

class="accordion-item"> ## id="wmHead">
data-bs-parent="#advRenderAcc">
class="accordion-body">

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

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, sur Linux, d'ajouter les deux bibliothèques natives requises par IronPDF (libnss3 et libatk1.0-0).

Dockerfile multi-é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 construction 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 noterWindows containers? Remplacez 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 de Chromium sont intégrées.

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.

ConseilsConseil de dépannage: Si les journaux du conteneur affichent une erreur "libnss3.so not found", confirmez que libnss3 et libatk1.0-0 sont tous deux présents. Les images alpines 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 de PDF existants en .NET Core ?

IronPDF considère chaque PDF — qu'il soit généré par IronPDF, Adobe® Acrobat ou des outils tiers — comme un objet PdfDocument de première classe qui peut être ouvert, modifié, sécurisé et sauvegardé 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 cryptés, tandis que PdfDocument.Merge concatène un nombre arbitraire de documents dans 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 rasterisation.
  • Extraction de contenu – ExtractAllText et ExtractAllImages extraient du texte brut UTF-8 ou des flux d'images binaires pour l'archivage ultérieur ou les pipelines AI.
    IronPDF sécurise un document en deux étapes : chiffrement 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.
  • 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, donc le flux de travail est identique sur .NET 8 LTS aujourd'hui et se compile sans changement sur la préversion .NET 9 et la prochaine sortie .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 autorisations -- 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 timestamp RFC 3161 et une chaîne de certificats, créant des hachages à preuve de falsification reconnus par Adobe® Acrobat et d'autres visualiseurs ISO 32000-2.
  • API unique -- le chiffrement et la signature modifient la même instance PdfDocument, évitant ainsi plusieurs passes de fichiers et préservant les polices internes, les calques et les métadonnées.

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

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. Attendre les JavaScript tardifs 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 les séries de factures, créez un PDF modèle avec des espaces réservés comme [[name]] et effectuez un remplacement de texte au lieu de reconstruire un 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(), log DevTools timeline for slow SPA hydrations

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é est 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 des classes, 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 utilisant 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 utilisant 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 technique chez Iron Software et un ingénieur visionnaire pionnier dans la technologie des PDF en C#. En tant que développeur original derrière la base de code principale d'Iron Software, il a façonné l'architecture du produit 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 16,685,821 | Version : 2025.12 vient de sortir