Comment ajouter un en-tête et un pied de page dans un PDF en utilisant iTextSharp et IronPDF en C# avec exemple

Ajouter des en-têtes et des pieds de page aux documents PDF

L'ajout d'en-têtes et de pieds de page aux documents PDF est essentiel pour créer des rapports, des factures et des documents commerciaux professionnels. Alors que de nombreux développeurs recherchent des solutions iTextSharp en utilisant PdfPageEventHelper et la méthode OnEndPage, les bibliothèques .NET modernes offrent des approches beaucoup plus simples pour obtenir les mêmes résultats.

Ce tutoriel montre comment ajouter un exemple d'en-tête et de pied de page dans un PDF à l'aide de C#, en comparant l'approche traditionnelle d'iText 7 avec les méthodes rationalisées d'IronPDF. À la fin, vous comprendrez les deux implémentations - de la création d'un nouveau document à la génération du fichier PDF final - et pourrez choisir l'approche qui correspond le mieux aux exigences de votre projet.

Comment ajouter un en-tête et un pied de page dans un PDF en utilisant iTextSharp et IronPDF en C# avec un exemple : Image 1 - IronPDF

Pourquoi les en-têtes et pieds de page PDF sont-ils importants dans la génération de documents ?

Les en-têtes et les pieds de page remplissent des fonctions essentielles dans les documents PDF professionnels. La traduction doit rester professionnelle, préserver l'exactitude technique tout en expliquant les fonctionnalités et les avantages de ces outils de développement.

Dans les environnements d'entreprise, les en-têtes et les pieds de page ont souvent une signification juridique. Les rapports financiers nécessitent des horodatages pour les pistes d'audit. Les contrats doivent être numérotés pour garantir leur exhaustivité. Les documents internes peuvent nécessiter des avis de confidentialité sur chaque page. Pour répondre à ces exigences au niveau programmatique, il faut une bibliothèque PDF qui gère de manière fiable l'injection de contenu au niveau de la page.

Comment ajouter un en-tête et un pied de page dans un PDF en utilisant iTextSharp et IronPDF en C# avec un exemple : Image 2 - Caractéristiques

Quel est le moyen le plus simple d'ajouter des en-têtes et des pieds de page en C#?

IronPDF fournit l'approche la plus directe pour ajouter des en-têtes et des pieds de page aux documents PDF dans les applications .NET. En utilisant la classe ChromePdfRenderer combinée avec TextHeaderFooter ou HtmlHeaderFooter, les développeurs peuvent générer des en-têtes et des pieds de page avec un minimum de code - pas besoin de créer des cellules séparées ou de gérer manuellement un objet contentbyte.

Comment ajouter un en-tête et un pied de page dans un PDF en utilisant iTextSharp et IronPDF en C# avec un exemple : Image 3 - Comment ajouter un en-tête et un pied de page dans un PDF - IronPDF

Dans les anciens modèles iTextSharp, les développeurs créaient souvent des méthodes d'aide telles que private static void AddContent()-ou des routines portant un nom similaire telles que private static void addcontentpour injecter manuellement la logique de l'en-tête et du pied de page. IronPDF élimine totalement la nécessité d'utiliser ce type de texte passe-partout.

Voici un exemple complet qui ajoute un en-tête et un pied de page à un fichier PDF :

using IronPdf;

// Initialize the PDF renderer
var renderer = new ChromePdfRenderer();

// Configure the text header with header text
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "Quarterly Sales Report",
    DrawDividerLine = true,
    FontSize = 14
};

// Configure the text footer with page number
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    LeftText = "{date}",
    RightText = "Page {page} of {total-pages}",
    DrawDividerLine = true,
    FontSize = 10
};

// Set margins to accommodate header and footer
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;

// Generate PDF from HTML content
var pdf = renderer.RenderHtmlAsPdf("<h1>Sales Data</h1><p>Content goes here...</p>");
pdf.SaveAs("report-with-headers.pdf");

using IronPdf;

// Initialize the PDF renderer
var renderer = new ChromePdfRenderer();

// Configure the text header with header text
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "Quarterly Sales Report",
    DrawDividerLine = true,
    FontSize = 14
};

// Configure the text footer with page number
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    LeftText = "{date}",
    RightText = "Page {page} of {total-pages}",
    DrawDividerLine = true,
    FontSize = 10
};

// Set margins to accommodate header and footer
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;

// Generate PDF from HTML content
var pdf = renderer.RenderHtmlAsPdf("<h1>Sales Data</h1><p>Content goes here...</p>");
pdf.SaveAs("report-with-headers.pdf");

Imports IronPdf

' Initialize the PDF renderer
Dim renderer As New ChromePdfRenderer()

' Configure the text header with header text
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .CenterText = "Quarterly Sales Report",
    .DrawDividerLine = True,
    .FontSize = 14
}

' Configure the text footer with page number
renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
    .LeftText = "{date}",
    .RightText = "Page {page} of {total-pages}",
    .DrawDividerLine = True,
    .FontSize = 10
}

' Set margins to accommodate header and footer
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25

' Generate PDF from HTML content
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sales Data</h1><p>Content goes here...</p>")
pdf.SaveAs("report-with-headers.pdf")

Le code source ci-dessus illustre plusieurs concepts clés. La classe TextHeaderFooter fournit des propriétés permettant de positionner le texte à gauche, au centre ou à droite de la zone d'en-tête/pied de page. La propriété DrawDividerLine ajoute une ligne de séparation professionnelle entre l'en-tête/pied de page et le contenu principal du document. Les champs fusionnables tels que {page}, {total-pages} et {date} se remplissent automatiquement avec des valeurs dynamiques lors de la génération du PDF.

Comment créer des en-têtes et des pieds de page au format HTML ?

Pour les conceptions plus sophistiquées, la classe HtmlHeaderFooter d'IronPDF permet un stylisme HTML et CSS complet. Cette approche est particulièrement utile lorsque les en-têtes doivent inclure une image de logo, des mises en page complexes ou un style spécifique à une marque, sans créer manuellement des objets PdfPCell ou utiliser de nouveaux constructeurs Phrase.

using IronPdf;
using System;
var renderer = new ChromePdfRenderer();
// Create an HTML header with logo and styling
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; font-family: Arial, sans-serif;'>
            <img src='logo.png' style='height: 30px; float: left;' />
            <span style='float: right; font-size: 12px; color: #666;'>
                Confidential Document
            </span>
        </div>",
    MaxHeight = 25,
    DrawDividerLine = true,
    BaseUrl = new Uri(@"C:\assets\").AbsoluteUri
};
// Create an HTML footer with page numbering
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='text-align: center; font-size: 10px; color: #999;'>
            <span>Generated on {date} at {time}</span>
            <br/>
            <span>Page {page} of {total-pages}</span>
        </div>",
    MaxHeight = 20
};
renderer.RenderingOptions.MarginTop = 30;
renderer.RenderingOptions.MarginBottom = 25;
var pdf = renderer.RenderHtmlAsPdf("<h1>Project Proposal</h1><p>Document content...</p>");
pdf.SaveAs("styled-document.pdf");

using IronPdf;
using System;
var renderer = new ChromePdfRenderer();
// Create an HTML header with logo and styling
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; font-family: Arial, sans-serif;'>
            <img src='logo.png' style='height: 30px; float: left;' />
            <span style='float: right; font-size: 12px; color: #666;'>
                Confidential Document
            </span>
        </div>",
    MaxHeight = 25,
    DrawDividerLine = true,
    BaseUrl = new Uri(@"C:\assets\").AbsoluteUri
};
// Create an HTML footer with page numbering
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='text-align: center; font-size: 10px; color: #999;'>
            <span>Generated on {date} at {time}</span>
            <br/>
            <span>Page {page} of {total-pages}</span>
        </div>",
    MaxHeight = 20
};
renderer.RenderingOptions.MarginTop = 30;
renderer.RenderingOptions.MarginBottom = 25;
var pdf = renderer.RenderHtmlAsPdf("<h1>Project Proposal</h1><p>Document content...</p>");
pdf.SaveAs("styled-document.pdf");

Imports IronPdf
Imports System

Dim renderer As New ChromePdfRenderer()

' Create an HTML header with logo and styling
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; font-family: Arial, sans-serif;'>
            <img src='logo.png' style='height: 30px; float: left;' />
            <span style='float: right; font-size: 12px; color: #666;'>
                Confidential Document
            </span>
        </div>",
    .MaxHeight = 25,
    .DrawDividerLine = True,
    .BaseUrl = New Uri("C:\assets\").AbsoluteUri
}

' Create an HTML footer with page numbering
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='text-align: center; font-size: 10px; color: #999;'>
            <span>Generated on {date} at {time}</span>
            <br/>
            <span>Page {page} of {total-pages}</span>
        </div>",
    .MaxHeight = 20
}

renderer.RenderingOptions.MarginTop = 30
renderer.RenderingOptions.MarginBottom = 25

Dim pdf = renderer.RenderHtmlAsPdf("<h1>Project Proposal</h1><p>Document content...</p>")
pdf.SaveAs("styled-document.pdf")

Cet exemple de code montre comment les en-têtes HTML peuvent incorporer des images à côté du texte. La propriété BaseUrl établit le chemin racine pour la résolution des URL d'images relatives spécifiées dans la chaîne filename, ce qui facilite l'inclusion de logos d'entreprise ou d'autres graphiques. La propriété MaxHeight permet de s'assurer que l'en-tête ne dépasse pas les dimensions spécifiées, afin de maintenir une mise en page cohérente du document.

Les champs fusionnables ({page}, {total-pages}, {url}, {date}, {time}, {html-title}, {pdf-title}) fonctionnent de manière identique dans les en-têtes et les pieds de page HTML, ce qui permet d'insérer du contenu dynamique sans code supplémentaire. Pour obtenir des conseils complets sur la mise en œuvre de divers styles d'en-tête, consultez le Guide pratique sur les en-têtes et les pieds de page.

L'approche HTML est particulièrement adaptée à la création de documents de marque. Les équipes marketing peuvent fournir des modèles HTML que les développeurs intègrent directement, garantissant ainsi une reproduction au pixel près des conceptions approuvées. Les propriétés CSS telles que font-family, color, background-color et border fonctionnent comme prévu, permettant des traitements visuels sophistiqués qui nécessiteraient un code de bas niveau important dans d'autres bibliothèques.

Comment ajouter des en-têtes à des documents PDF existants ?

Un besoin courant consiste à ajouter des en-têtes et des pieds de page à des fichiers PDF existants, qu'il s'agisse de documents téléchargés, de fichiers fusionnés ou de PDF générés par d'autres systèmes. IronPDF gère ce scénario avec élégance grâce aux méthodes AddHtmlHeaders et AddHtmlFooters.

using IronPdf;
// Load an existing PDF document
var pdf = PdfDocument.FromFile("customer-profile.pdf");
// Define the header to add with header description
var header = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: center;'>REVISED COPY - {date}</div>",
    MaxHeight = 20
};
// Define the footer to add
var footer = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: right;'>Page {page}</div>",
    MaxHeight = 15
};
// Apply headers and footers to all pages
pdf.AddHtmlHeaders(header);
pdf.AddHtmlFooters(footer);
pdf.SaveAs("document-with-new-headers.pdf");

using IronPdf;
// Load an existing PDF document
var pdf = PdfDocument.FromFile("customer-profile.pdf");
// Define the header to add with header description
var header = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: center;'>REVISED COPY - {date}</div>",
    MaxHeight = 20
};
// Define the footer to add
var footer = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: right;'>Page {page}</div>",
    MaxHeight = 15
};
// Apply headers and footers to all pages
pdf.AddHtmlHeaders(header);
pdf.AddHtmlFooters(footer);
pdf.SaveAs("document-with-new-headers.pdf");

Imports IronPdf

' Load an existing PDF document
Dim pdf = PdfDocument.FromFile("customer-profile.pdf")

' Define the header to add with header description
Dim header As New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align: center;'>REVISED COPY - {date}</div>",
    .MaxHeight = 20
}

' Define the footer to add
Dim footer As New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align: right;'>Page {page}</div>",
    .MaxHeight = 15
}

' Apply headers and footers to all pages
pdf.AddHtmlHeaders(header)
pdf.AddHtmlFooters(footer)
pdf.SaveAs("document-with-new-headers.pdf")

La classe PdfDocument représente un PDF chargé ou rendu et fournit des méthodes pour les modifications post-rendu. Cette séparation entre le rendu et la modification permet des flux de travail où les documents PDF passent par plusieurs étapes de traitement. La méthode AddHtmlHeaders applique automatiquement l'en-tête à chaque page, bien que vous puissiez également cibler des pages spécifiques en transmettant une collection d'indices de page.

À quoi ressemble l'approche d'iText 7?

Les développeurs qui connaissent iText 7 (le successeur d'iTextSharp) savent que l'ajout d'en-têtes et de pieds de page nécessite la mise en œuvre de gestionnaires d'événements. La bibliothèque utilise un système d'événements de page dans lequel vous créez un fichier de classe qui répond aux événements du cycle de vie du document comme OnEndPage et OnCloseDocument.

Voici à quoi ressemble la même implémentation d'en-tête/pied de page avec iText 7, en utilisant la classe publique ITextEvents :

using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.Kernel.Events;
using iText.Kernel.Geom;
using iText.Layout.Properties;

// Event handler class for headers and footers - similar to PdfPageEventHelper
public class ITextEvents : IEventHandler
{
    // Private string for header text
    private string _header;
    public string Header
    {
        get { return _header; }
        set { _header = value; }
    }

    public void HandleEvent(Event currentEvent)
    {
        PdfDocumentEvent docEvent = (PdfDocumentEvent)currentEvent;
        PdfDocument pdfDoc = docEvent.GetDocument();
        PdfPage page = docEvent.GetPage();
        Rectangle pageSize = page.GetPageSize();

        // Create new PdfCanvas for the contentbyte object
        PdfCanvas pdfCanvas = new PdfCanvas(
            page.NewContentStreamBefore(),
            page.GetResources(),
            pdfDoc);
        Canvas canvas = new Canvas(pdfCanvas, pageSize);

        // Add header text
        canvas.ShowTextAligned(
            new Paragraph("Quarterly Sales Report"),
            pageSize.GetWidth() / 2,
            pageSize.GetTop() - 20,
            TextAlignment.CENTER);

        // Add footer with page number
        int pageNumber = pdfDoc.GetPageNumber(page);
        canvas.ShowTextAligned(
            new Paragraph($"Page {pageNumber}"),
            pageSize.GetWidth() / 2,
            pageSize.GetBottom() + 20,
            TextAlignment.CENTER);
        canvas.Close();
    }
}

// Usage in main code - private void CreatePdf pattern
public static void Main(string[] args)
{
    PdfWriter writer = new PdfWriter("report.pdf");
    PdfDocument pdfDoc = new PdfDocument(writer);
    Document document = new Document(pdfDoc);

    // Register the event handler for END_PAGE
    pdfDoc.AddEventHandler(PdfDocumentEvent.END_PAGE, new ITextEvents());

    document.Add(new Paragraph("Sales Data"));
    document.Add(new Paragraph("Content goes here..."));
    document.Close();
}

using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.Kernel.Events;
using iText.Kernel.Geom;
using iText.Layout.Properties;

// Event handler class for headers and footers - similar to PdfPageEventHelper
public class ITextEvents : IEventHandler
{
    // Private string for header text
    private string _header;
    public string Header
    {
        get { return _header; }
        set { _header = value; }
    }

    public void HandleEvent(Event currentEvent)
    {
        PdfDocumentEvent docEvent = (PdfDocumentEvent)currentEvent;
        PdfDocument pdfDoc = docEvent.GetDocument();
        PdfPage page = docEvent.GetPage();
        Rectangle pageSize = page.GetPageSize();

        // Create new PdfCanvas for the contentbyte object
        PdfCanvas pdfCanvas = new PdfCanvas(
            page.NewContentStreamBefore(),
            page.GetResources(),
            pdfDoc);
        Canvas canvas = new Canvas(pdfCanvas, pageSize);

        // Add header text
        canvas.ShowTextAligned(
            new Paragraph("Quarterly Sales Report"),
            pageSize.GetWidth() / 2,
            pageSize.GetTop() - 20,
            TextAlignment.CENTER);

        // Add footer with page number
        int pageNumber = pdfDoc.GetPageNumber(page);
        canvas.ShowTextAligned(
            new Paragraph($"Page {pageNumber}"),
            pageSize.GetWidth() / 2,
            pageSize.GetBottom() + 20,
            TextAlignment.CENTER);
        canvas.Close();
    }
}

// Usage in main code - private void CreatePdf pattern
public static void Main(string[] args)
{
    PdfWriter writer = new PdfWriter("report.pdf");
    PdfDocument pdfDoc = new PdfDocument(writer);
    Document document = new Document(pdfDoc);

    // Register the event handler for END_PAGE
    pdfDoc.AddEventHandler(PdfDocumentEvent.END_PAGE, new ITextEvents());

    document.Add(new Paragraph("Sales Data"));
    document.Add(new Paragraph("Content goes here..."));
    document.Close();
}

Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports iText.Kernel.Events
Imports iText.Kernel.Geom
Imports iText.Layout.Properties

' Event handler class for headers and footers - similar to PdfPageEventHelper
Public Class ITextEvents
    Implements IEventHandler

    ' Private string for header text
    Private _header As String
    Public Property Header As String
        Get
            Return _header
        End Get
        Set(value As String)
            _header = value
        End Set
    End Property

    Public Sub HandleEvent(currentEvent As [Event]) Implements IEventHandler.HandleEvent
        Dim docEvent As PdfDocumentEvent = CType(currentEvent, PdfDocumentEvent)
        Dim pdfDoc As PdfDocument = docEvent.GetDocument()
        Dim page As PdfPage = docEvent.GetPage()
        Dim pageSize As Rectangle = page.GetPageSize()

        ' Create new PdfCanvas for the contentbyte object
        Dim pdfCanvas As New PdfCanvas(page.NewContentStreamBefore(), page.GetResources(), pdfDoc)
        Dim canvas As New Canvas(pdfCanvas, pageSize)

        ' Add header text
        canvas.ShowTextAligned(New Paragraph("Quarterly Sales Report"), pageSize.GetWidth() / 2, pageSize.GetTop() - 20, TextAlignment.CENTER)

        ' Add footer with page number
        Dim pageNumber As Integer = pdfDoc.GetPageNumber(page)
        canvas.ShowTextAligned(New Paragraph($"Page {pageNumber}"), pageSize.GetWidth() / 2, pageSize.GetBottom() + 20, TextAlignment.CENTER)
        canvas.Close()
    End Sub
End Class

' Usage in main code - private void CreatePdf pattern
Public Module Program
    Public Sub Main(args As String())
        Dim writer As New PdfWriter("report.pdf")
        Dim pdfDoc As New PdfDocument(writer)
        Dim document As New Document(pdfDoc)

        ' Register the event handler for END_PAGE
        pdfDoc.AddEventHandler(PdfDocumentEvent.END_PAGE, New ITextEvents())

        document.Add(New Paragraph("Sales Data"))
        document.Add(New Paragraph("Content goes here..."))
        document.Close()
    End Sub
End Module

Cette mise en œuvre démontre la différence architecturale fondamentale entre les bibliothèques. iText 7 nécessite la création d'une classe de gestionnaire distincte qui met en œuvre IEventHandler (similaire à l'ancien PdfPageEventHelper), le calcul manuel des positions de page à l'aide de coordonnées flottantes et la gestion des objets PdfCanvas et Canvas pour les opérations de dessin. Le gestionnaire reçoit des événements pour chaque page via le type d'événement END_PAGE, un détail qui fait trébucher de nombreux développeurs qui utilisent par erreur START_PAGE.

Comment les deux approches se comparent-elles pour les scénarios les plus courants ?

La différence devient plus prononcée lors de la mise en œuvre de fonctionnalités telles que la numérotation des pages avec des totaux. Avec IronPDF, le champ fusionnable {total-pages} gère cela automatiquement. Avec iText 7, vous devez utiliser des modèles PdfFormXObject qui sont remplis lors de l'événement OnCloseDocument - un modèle qui nécessite de comprendre le cycle de vie de la génération PDF.

L'expérience de développement diffère également de manière significative lors de la résolution de problèmes. L'approche d'IronPDF basée sur le HTML signifie que vous pouvez prévisualiser la conception de votre en-tête dans un navigateur avant de l'intégrer dans votre code de génération de PDF. Si quelque chose ne semble pas correct, vous pouvez ajuster le HTML et le CSS en utilisant les outils de développement du navigateur qui vous sont familiers. Avec iText 7, le débogage des problèmes de positionnement nécessite la génération répétée de PDF de test et la mesure manuelle des coordonnées.

L'approche basée sur le langage HTML permet aux développeurs de tirer parti de leurs compétences en matière de développement web. Toute mise en page réalisable avec HTML et CSS fonctionne dans les en-têtes et pieds de page IronPdf, des arrangements flexbox aux conceptions réactives. L'exemple HTML Headers and Footers montre des possibilités de style supplémentaires. Comparez cette approche à celle d'iText, où vous devez créer de nouvelles structures PdfPTable, ajouter du texte à l'aide de nouveaux constructeurs Phrase et positionner manuellement les éléments à l'aide de nouveaux tableaux de flottants.

Qu'en est-il des déploiements multiplateformes et des déploiements de conteneurs ?

Les applications .NET modernes sont souvent déployées dans des conteneurs Linux, Azure App Services ou des fonctions AWS Lambda. IronPdf prend en charge le déploiement multiplateforme sur Windows, Linux et macOS sans nécessiter de configuration supplémentaire. La bibliothèque fonctionne dans des conteneurs Docker dès sa sortie de l'emballage, ce qui la rend adaptée aux architectures microservices et aux applications cloud-natives.

Cette capacité multiplateforme s'étend à la fonctionnalité d'en-tête et de pied de page - le même code qui génère des PDF avec des en-têtes sur une machine de développement Windows produit un résultat identique lorsqu'il est déployé sur un serveur de production Linux. Il n'est pas nécessaire d'installer des polices supplémentaires, de configurer des moteurs de rendu ou de gérer des chemins de code spécifiques à une plateforme.

Pour les équipes qui exécutent des charges de travail conteneurisées, la documentation d'IronPDF sur le déploiement de Docker fournit des conseils de configuration pour diverses images de base et plateformes d'orchestration. Le comportement cohérent de la bibliothèque dans tous les environnements élimine une source fréquente de bogues dans les flux de travail de génération de PDF.

Comment gérer des en-têtes différents pour des pages différentes ?

Certains documents exigent que la première page ait un en-tête différent (ou pas d'en-tête), tandis que les pages suivantes utilisent un format standard. IronPDF prend en charge cela grâce à l'application d'en-tête basée sur l'index de page - pas besoin de vérifier les conditions à l'intérieur des void OnEndPage handlers ou de gérer les compteurs de boucle int i :

using IronPdf;
using System.Linq;
var renderer = new ChromePdfRenderer();
// Build multi-page HTML and include a print page-break between pages
var pages = new List<string>
{
    "<section><h1>Title Page</h1><p>Intro text on page 1.</p></section>",
    "<section><h2>Report</h2><p>Detailed report content on page 2.</p></section>",
    "<section><h2>Appendix</h2><p>Appendix content on page 3.</p></section>"
};
var sb = new StringBuilder();
sb.AppendLine("<!doctype html><html><head><meta charset='utf-8'>");
sb.AppendLine("<style>");
sb.AppendLine("  body { font-family: Arial, sans-serif; margin: 20px; }");
sb.AppendLine("  .page-break { page-break-after: always; }");
sb.AppendLine("  @media print { .page-break { display:block; } }");
sb.AppendLine("</style>");
sb.AppendLine("</head><body>");
for (int i = 0; i < pages.Count; i++)
{
    sb.AppendLine(pages[i]);
    // add page break between pages, but not after last page
    if (i < pages.Count - 1)
        sb.AppendLine("<div class='page-break'></div>");
}
sb.AppendLine("</body></html>");
var multiPageHtmlContent = sb.ToString();
var pdf = renderer.RenderHtmlAsPdf(multiPageHtmlContent);
// Create the standard header for checking header footer placement
var standardHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: center;'>Standard Header - Page {page}</div>",
    MaxHeight = 20
};
// Apply to all pages except the first (index 0) - start row at 1
var pageIndices = Enumerable.Range(1, pdf.PageCount - 1).ToList();
pdf.AddHtmlHeaders(standardHeader, 1, pageIndices);
pdf.SaveAs("document-skip-first-page-header.pdf");

using IronPdf;
using System.Linq;
var renderer = new ChromePdfRenderer();
// Build multi-page HTML and include a print page-break between pages
var pages = new List<string>
{
    "<section><h1>Title Page</h1><p>Intro text on page 1.</p></section>",
    "<section><h2>Report</h2><p>Detailed report content on page 2.</p></section>",
    "<section><h2>Appendix</h2><p>Appendix content on page 3.</p></section>"
};
var sb = new StringBuilder();
sb.AppendLine("<!doctype html><html><head><meta charset='utf-8'>");
sb.AppendLine("<style>");
sb.AppendLine("  body { font-family: Arial, sans-serif; margin: 20px; }");
sb.AppendLine("  .page-break { page-break-after: always; }");
sb.AppendLine("  @media print { .page-break { display:block; } }");
sb.AppendLine("</style>");
sb.AppendLine("</head><body>");
for (int i = 0; i < pages.Count; i++)
{
    sb.AppendLine(pages[i]);
    // add page break between pages, but not after last page
    if (i < pages.Count - 1)
        sb.AppendLine("<div class='page-break'></div>");
}
sb.AppendLine("</body></html>");
var multiPageHtmlContent = sb.ToString();
var pdf = renderer.RenderHtmlAsPdf(multiPageHtmlContent);
// Create the standard header for checking header footer placement
var standardHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: center;'>Standard Header - Page {page}</div>",
    MaxHeight = 20
};
// Apply to all pages except the first (index 0) - start row at 1
var pageIndices = Enumerable.Range(1, pdf.PageCount - 1).ToList();
pdf.AddHtmlHeaders(standardHeader, 1, pageIndices);
pdf.SaveAs("document-skip-first-page-header.pdf");

Imports IronPdf
Imports System.Linq
Imports System.Text

Dim renderer As New ChromePdfRenderer()
' Build multi-page HTML and include a print page-break between pages
Dim pages As New List(Of String) From {
    "<section><h1>Title Page</h1><p>Intro text on page 1.</p></section>",
    "<section><h2>Report</h2><p>Detailed report content on page 2.</p></section>",
    "<section><h2>Appendix</h2><p>Appendix content on page 3.</p></section>"
}
Dim sb As New StringBuilder()
sb.AppendLine("<!doctype html><html><head><meta charset='utf-8'>")
sb.AppendLine("<style>")
sb.AppendLine("  body { font-family: Arial, sans-serif; margin: 20px; }")
sb.AppendLine("  .page-break { page-break-after: always; }")
sb.AppendLine("  @media print { .page-break { display:block; } }")
sb.AppendLine("</style>")
sb.AppendLine("</head><body>")
For i As Integer = 0 To pages.Count - 1
    sb.AppendLine(pages(i))
    ' add page break between pages, but not after last page
    If i < pages.Count - 1 Then
        sb.AppendLine("<div class='page-break'></div>")
    End If
Next
sb.AppendLine("</body></html>")
Dim multiPageHtmlContent As String = sb.ToString()
Dim pdf = renderer.RenderHtmlAsPdf(multiPageHtmlContent)
' Create the standard header for checking header footer placement
Dim standardHeader As New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align: center;'>Standard Header - Page {page}</div>",
    .MaxHeight = 20
}
' Apply to all pages except the first (index 0) - start row at 1
Dim pageIndices = Enumerable.Range(1, pdf.PageCount - 1).ToList()
pdf.AddHtmlHeaders(standardHeader, 1, pageIndices)
pdf.SaveAs("document-skip-first-page-header.pdf")

Le deuxième paramètre de AddHtmlHeaders spécifie le numéro de la page de départ pour le champ fusionnable {page}, tandis que le troisième paramètre accepte une collection d'indices de page pour recevoir l'en-tête (aucune ligne de fin n'est nécessaire - la liste définit exactement les pages). Ce contrôle granulaire permet des mises en page de documents complexes sans logique conditionnelle alambiquée. L'exemple Advanced Headers and Footers example couvre des scénarios supplémentaires, notamment la différenciation des pages paires et impaires.

Quels sont les paramètres qui contrôlent l'apparence de l'en-tête et du pied de page ?

L'ajustement des en-têtes et des pieds de page implique plusieurs propriétés qui affectent le positionnement et la présentation visuelle. La classe TextHeaderFooter offre ces options de personnalisation pour contrôler l'affichage de vos sections d'en-tête et de pied de page :

var footer = new TextHeaderFooter
{
    LeftText = "Confidential",
    CenterText = "{pdf-title}",
    RightText = "Page {page}",
    Font = IronSoftware.Drawing.FontTypes.Arial,
    FontSize = 9,
    DrawDividerLine = true,
    DrawDividerLineColor = IronSoftware.Drawing.Color.Gray
};
renderer.RenderingOptions.TextFooter = footer;
renderer.RenderingOptions.MarginBottom = 20;

var footer = new TextHeaderFooter
{
    LeftText = "Confidential",
    CenterText = "{pdf-title}",
    RightText = "Page {page}",
    Font = IronSoftware.Drawing.FontTypes.Arial,
    FontSize = 9,
    DrawDividerLine = true,
    DrawDividerLineColor = IronSoftware.Drawing.Color.Gray
};
renderer.RenderingOptions.TextFooter = footer;
renderer.RenderingOptions.MarginBottom = 20;

Imports IronSoftware.Drawing

Dim footer As New TextHeaderFooter With {
    .LeftText = "Confidential",
    .CenterText = "{pdf-title}",
    .RightText = "Page {page}",
    .Font = FontTypes.Arial,
    .FontSize = 9,
    .DrawDividerLine = True,
    .DrawDividerLineColor = Color.Gray
}
renderer.RenderingOptions.TextFooter = footer
renderer.RenderingOptions.MarginBottom = 20

La propriété Font accepte les valeurs de Iron Software.Drawing.FontTypes, notamment Helvetica, Arial, Courier et Times New Roman. La propriété Spacing contrôle l'espace entre la ligne de séparation et le contenu du texte. Ces propriétés permettent un contrôle typographique sans nécessiter de connaissances en matière de CSS.

Pour les en-têtes et les pieds de page HTML, la propriété LoadStylesAndCSSFromMainHtmlDocument hérite facultativement des styles du document principal rendu, ce qui garantit la cohérence visuelle entre les en-têtes et le corps du texte. Ceci est particulièrement utile lorsque votre document principal utilise des feuilles de style CSS personnalisées qui doivent également s'appliquer aux régions de l'en-tête et du pied de page.

La propriété DrawDividerLine ajoute une règle horizontale professionnelle pour tracer la séparation des lignes entre l'en-tête/le pied de page et le contenu principal. Vous pouvez personnaliser la couleur de la ligne à l'aide de DrawDividerLineColor pour qu'elle corresponde aux couleurs de votre marque ou au thème de votre document.

Comment mettre en œuvre un contenu dynamique au-delà des numéros de page ?

Le système de champs fusionnables prend en charge plusieurs valeurs dynamiques qui se remplissent automatiquement lors du rendu :

• {page} - Numéro de la page actuelle
• {total-pages} - Nombre final de pages dans le document
• {date} - Date actuelle au format local
• {time} - Heure actuelle au format local
• {html-title} - Contenu de la balise <title> du code HTML source
• {pdf-title} - Titre des métadonnées du document PDF
• {url} - URL source lors du rendu à partir d'une adresse web

La combinaison de ces champs permet de créer des bas de page sophistiqués, fréquents dans les documents commerciaux. Les services juridiques ont souvent besoin de pieds de page indiquant le titre du document, la date et le nombre de pages. Les rapports financiers peuvent nécessiter des horodatages pour des raisons de conformité réglementaire. Les champs fusionnables répondent à ces exigences sans nécessiter de code personnalisé pour chaque type de document.

Pour un contenu réellement dynamique - des valeurs déterminées au moment de l'exécution - vous pouvez construire la chaîne du fragment HTML avec des valeurs interpolées avant de l'affecter à la propriété HtmlFragment. Cette approche permet d'inclure dans les en-têtes des valeurs extraites de la base de données, des informations sur l'utilisateur ou des données calculées :

string userName = GetCurrentUserName();
string documentVersion = "v2.3.1";
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = $"<div>Prepared by: {userName} 
 Version: {documentVersion} 
 Page {{page}}</div>",
    MaxHeight = 20
};

string userName = GetCurrentUserName();
string documentVersion = "v2.3.1";
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = $"<div>Prepared by: {userName} 
 Version: {documentVersion} 
 Page {{page}}</div>",
    MaxHeight = 20
};

Dim userName As String = GetCurrentUserName()
Dim documentVersion As String = "v2.3.1"
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = $"<div>Prepared by: {userName} Version: {documentVersion} Page {{page}}</div>",
    .MaxHeight = 20
}

Notez les doubles accolades autour de {page} lors de l'utilisation de l'interpolation de chaînes : elles permettent d'échapper aux accolades afin que le champ fusionnable soit préservé dans la chaîne finale. Ce modèle fonctionne de la même manière que les paramètres object sender, EventArgs e dans un code piloté par les événements, en conservant intacts les espaces réservés du cadre tout en injectant vos propres valeurs.

Commencer avec IronPDF

La mise en œuvre d'en-têtes et de pieds de page dans vos documents PDF ne prend que quelques minutes avec IronPDF. Installez la bibliothèque via NuGet Package Manager :

Install-Package IronPdf

Comment ajouter un en-tête et un pied de page dans un PDF en utilisant iTextSharp et IronPDF en C# avec un exemple : Image 10 - Installation

Ou en utilisant l'interface de ligne de commande .NET :

dotnet add package IronPDF

dotnet add package IronPDF

La bibliothèque ne nécessite aucune dépendance externe et fonctionne immédiatement après son installation. Commencez par consulter la documentation Getting Started pour explorer l'ensemble des fonctionnalités de génération et de manipulation de fichiers PDF.

Essayez IronPDF avec une version d'essai gratuite pour tester ces implémentations d'en-têtes et de pieds de page dans vos propres projets. Pour les déploiements en production, les options de licence s'adaptent à toutes les situations, des développeurs individuels aux équipes d'entreprise.

Comment ajouter un en-tête et un pied de page dans un PDF en utilisant iTextSharp et IronPDF en C# avec un exemple : Image 11 - Licence

Conclusion

L'ajout d'en-têtes et de pieds de page à des documents PDF en C# va de simple à complexe, en fonction du choix de votre bibliothèque. Alors qu'iText 7 offre un contrôle de bas niveau grâce à des gestionnaires d'événements tels que public override void OnEndPage et des opérations de canevas utilisant les motifs PdfWriter writer, PdfContentByte cb, IronPDF offre la même fonctionnalité par le biais d'une API intuitive qui exploite des concepts HTML et CSS familiers.

Pour les développeurs qui donnent la priorité à une mise en œuvre rapide et à un code maintenable, l'approche d'IronPDF réduit la mise en œuvre de l'en-tête et du pied de page de dizaines de lignes, y compris les gestionnaires public class PdfFooter, les configurations PdfPCell cell et les nouvelles structures PdfPTable à seulement quelques affectations de propriétés. L'option de stylisation basée sur HTML permet de créer des designs sophistiqués sans avoir à apprendre les systèmes de coordonnées spécifiques au PDF ou à gérer les en-têtes de disposition du contenu.

Qu'il s'agisse de générer des factures portant la marque de l'entreprise, des rapports avec navigation par page ou des contrats nécessitant des horodatages, les en-têtes et pieds de page professionnels établissent la crédibilité du document. La documentation IronPDF fournit des exemples supplémentaires et du matériel de référence API pour la mise en œuvre de ces fonctionnalités PDF et d'autres dans vos applications .NET.