Cómo añadir encabezado y pie de página en PDF utilizando iTextSharp y IronPDF en C# con ejemplo

Añadir encabezados y pies de página a documentos PDF

Añadir encabezados y pies de página a los documentos PDF es esencial para crear informes, facturas y documentos comerciales profesionales. Mientras que muchos desarrolladores buscan soluciones iTextSharp utilizando PdfPageEventHelper y el método OnEndPage, las bibliotecas .NET modernas ofrecen enfoques significativamente más sencillos para lograr los mismos resultados.

Este tutorial muestra cómo añadir un encabezado y un pie de página de muestra en un PDF utilizando C#, comparando el enfoque tradicional de iText 7 con los métodos simplificados de IronPDF. Al final, comprenderá ambas implementaciones, desde la creación de un nuevo documento hasta la generación del archivo PDF final, y podrá elegir el enfoque que mejor se adapte a los requisitos de su proyecto.

Cómo Añadir Encabezado y Pie de Página en PDF Usando iTextSharp y IronPDF en C# con Ejemplo: Imagen 1 - IronPDF

¿Por qué son importantes los encabezados y pies de página de PDF en la generación de documentos?

Los encabezados y pies de página desempeñan funciones críticas en los documentos PDF profesionales. Las traducciones deben ser coherentes con la marca mediante logotipos de imágenes, permitir la navegación por páginas con números de página, mostrar metadatos importantes como fechas y títulos de documentos, y establecer la autenticidad del documento mediante marcas de tiempo e información sobre la versión.

En entornos empresariales, los encabezados y pies de página suelen tener importancia jurídica. Los informes financieros requieren marcas de tiempo para realizar auditorías. Los contratos necesitan una numeración de páginas para garantizar su integridad. Los documentos internos pueden requerir avisos de confidencialidad en cada página. Cumplir estos requisitos mediante programación requiere una biblioteca PDF que gestione de forma fiable la inyección de contenido a nivel de página.

Cómo añadir encabezado y pie de página en PDF utilizando iTextSharp y IronPDF en C# con ejemplo: Imagen 2 - Características

¿Cuál es la forma más sencilla de añadir encabezados y pies de página en C#?

IronPDF ofrece el método más sencillo para añadir encabezados y pies de página a documentos PDF en aplicaciones .NET. Utilizando la clase ChromePdfRenderer combinada con TextHeaderFooter o HtmlHeaderFooter, los desarrolladores pueden generar encabezados y pies de página con un código mínimo, sin necesidad de crear celdas separadas o gestionar un objeto contentbyte manualmente.

Cómo Añadir Encabezado y Pie de Página en PDF Usando iTextSharp y IronPDF en C# con Ejemplo: Imagen 3 - Cómo añadir encabezado y pie de página en PDF - IronPDF

En los patrones antiguos de iTextSharp, los desarrolladores solían crear métodos de ayuda como private static void AddContent() -o rutinas de nombre similar como private static void addcontent - para inyectar manualmente la lógica de encabezado y pie de página. IronPDF elimina por completo la necesidad de este tipo de repeticiones.

He aquí un ejemplo completo que añade un encabezado y un pie de página a un archivo 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")

El código fuente anterior demuestra varios conceptos clave. La clase TextHeaderFooter proporciona propiedades para posicionar texto a la izquierda, centro o derecha del área de encabezado/pie de página. La propiedad DrawDividerLine añade una línea separadora profesional entre el encabezado/pie de página y el contenido principal del documento. Los campos fusionables como {page}, {total-pages} y {date} se rellenan automáticamente con valores dinámicos durante la generación del PDF.

¿Cómo crear encabezados y pies de página con estilo HTML?

Para diseños más sofisticados, la clase HtmlHeaderFooter de IronPDF permite un estilo HTML y CSS completo. Este enfoque es especialmente valioso cuando los encabezados deben incluir un logotipo de imagen, diseños complejos o estilos específicos de la marca, sin necesidad de crear manualmente objetos PdfPCell ni de utilizar nuevos constructores de 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")

Este código de ejemplo muestra cómo las cabeceras HTML pueden incorporar imágenes junto con el texto. La propiedad BaseUrl establece la ruta raíz para resolver las URL de imágenes relativas especificadas en la cadena filename, lo que facilita la inclusión de logotipos de empresa u otros gráficos. La propiedad MaxHeight garantiza que el encabezado no supere las dimensiones especificadas, manteniendo la coherencia en el diseño de los documentos.

Los campos fusionables ({page}, {total-pages}, {url}, {date}, {time}, {html-title}, {pdf-title}) funcionan de forma idéntica en encabezados y pies de página HTML, lo que permite insertar contenido dinámico sin código adicional. Para obtener una guía completa sobre la implementación de varios estilos de encabezado, consulte la Guía práctica de encabezados y pies de página.

El enfoque HTML brilla especialmente a la hora de crear documentos de marca. Los equipos de marketing pueden proporcionar plantillas HTML que los desarrolladores integran directamente, garantizando una reproducción perfecta de los diseños aprobados. Las propiedades CSS como family, color, color de fondo y border funcionan como se espera, permitiendo sofisticados tratamientos visuales que requerirían un extenso código de bajo nivel en otras bibliotecas.

¿Cómo se pueden añadir encabezados a documentos PDF existentes?

Un requisito común consiste en añadir encabezados y pies de página a archivos PDF ya existentes, ya sean documentos cargados, archivos fusionados o PDF generados por otros sistemas. IronPDF maneja este escenario elegantemente con los métodos AddHtmlHeaders y 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 clase PdfDocument representa un PDF cargado o renderizado y proporciona métodos para modificaciones posteriores a la renderización. Esta separación entre renderización y modificación permite flujos de trabajo en los que los documentos PDF pasan por varias etapas de procesamiento. El método AddHtmlHeaders aplica automáticamente el encabezado a todas las páginas, aunque también puede dirigirse a páginas específicas pasando una colección de índices de páginas.

¿Cómo es el enfoque de iText 7?

Los desarrolladores familiarizados con iText 7 (el sucesor de iTextSharp) saben que para añadir encabezados y pies de página es necesario implementar controladores de eventos. La biblioteca utiliza un sistema de eventos de página en el que se crea un archivo de clase que responde a eventos del ciclo de vida del documento como OnEndPage y OnCloseDocument.

Este es el aspecto de la misma implementación de encabezado/pie de página con iText 7, utilizando el patrón de la clase pública 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

Esta implementación demuestra la diferencia arquitectónica fundamental entre las bibliotecas. iText 7 requiere la creación de una clase manejadora independiente que implemente IEventHandler (similar al antiguo PdfPageEventHelper), el cálculo manual de las posiciones de página mediante coordenadas flotantes y la gestión de los objetos PdfCanvas y Canvas para las operaciones de dibujo. El manejador recibe eventos para cada página a través del tipo de evento END_PAGE, un detalle que confunde a muchos desarrolladores que utilizan erróneamente START_PAGE.

¿Cómo se comparan los dos enfoques en escenarios comunes?

La diferencia se hace más pronunciada cuando se implementan funciones como la numeración de páginas con totales. Con IronPDF, el campo combinable {total-pages} se encarga de esto automáticamente. Con iText 7, es necesario utilizar plantillas PdfFormXObject que se rellenan durante el evento OnCloseDocument, un patrón que requiere comprender el ciclo de vida de generación de PDF.

La experiencia de desarrollo también difiere significativamente a la hora de solucionar problemas. El enfoque basado en HTML de IronPDF permite previsualizar el diseño del encabezado en un navegador antes de integrarlo en el código de generación de PDF. Si algo parece incorrecto, puedes ajustar el HTML y el CSS utilizando las herramientas de desarrollo conocidas del navegador. Con iText 7, la depuración de problemas de posicionamiento requiere generar PDF de prueba repetidamente y medir manualmente las coordenadas.

El enfoque basado en HTML permite a los desarrolladores aprovechar sus conocimientos de desarrollo web. En los encabezados y pies de página de IronPDF funciona cualquier diseño que se pueda conseguir con HTML y CSS, desde arreglos flexbox hasta diseños adaptables. El ejemplo de encabezados y pies de página HTML muestra otras posibilidades de estilo. Compárelo con el enfoque iText, en el que tendría que crear nuevas estructuras PdfPTable, añadir texto utilizando nuevos constructores Phrase y posicionar manualmente los elementos utilizando nuevas matrices de flotadores.

¿Qué pasa con los despliegues multiplataforma y de contenedores?

Las aplicaciones .NET modernas a menudo se despliegan en contenedores Linux, Azure App Services o funciones AWS Lambda. IronPDF admite la implementación multiplataforma en Windows, Linux y macOS sin necesidad de configuración adicional. La biblioteca funciona en contenedores Docker, por lo que es adecuada para arquitecturas de microservicios y aplicaciones nativas en la nube.

Esta capacidad multiplataforma se extiende a la funcionalidad de encabezado y pie de página: el mismo código que genera PDF con encabezados en una máquina de desarrollo Windows produce resultados idénticos cuando se despliega en un servidor de producción Linux. No es necesario instalar fuentes adicionales, configurar motores de renderizado ni manejar rutas de código específicas de la plataforma.

Para los equipos que ejecutan cargas de trabajo en contenedores, la documentación de despliegue de Docker de IronPDF proporciona orientación para la configuración de varias imágenes base y plataformas de orquestación. El comportamiento coherente de la biblioteca en distintos entornos elimina una fuente común de errores del tipo "funciona en mi máquina" en los flujos de trabajo de generación de PDF.

¿Cómo se gestionan las diferentes cabeceras de las distintas páginas?

Algunos documentos requieren que la primera página tenga un encabezado diferente (o que no tenga encabezado), mientras que las páginas siguientes utilizan un formato estándar. IronPDF soporta esto a través de la aplicación de cabecera basada en el índice de páginas, sin necesidad de comprobar las condiciones dentro de los manejadores void OnEndPage o gestionar los contadores de bucle 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")

El segundo parámetro de AddHtmlHeaders especifica el número de página inicial para el campo fusionable {page}, mientras que el tercer parámetro acepta una colección de índices de páginas para recibir el encabezado (no es necesaria una fila final; la lista define exactamente las páginas). Este control granular permite diseñar documentos complejos sin una lógica condicional enrevesada. El Ejemplo avanzado de encabezados y pies de página cubre escenarios adicionales, incluida la diferenciación de páginas pares e impares.

¿Qué ajustes controlan la apariencia del encabezado y el pie de página?

El ajuste de los encabezados y pies de página implica varias propiedades que afectan al posicionamiento y la presentación visual. La clase TextHeaderFooter proporciona estas opciones de personalización para controlar cómo aparecen la sección de encabezado independiente y la sección de pie de página independiente:

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 propiedad Font acepta valores de IronSoftware.Drawing.FontTypes, incluidas Helvetica, Arial, Courier y Times New Roman. La propiedad Spacing controla el espacio entre la línea divisoria y el contenido del texto. Estas propiedades proporcionan control tipográfico sin requerir conocimientos de CSS.

Para los encabezados y pies de página basados en HTML, la propiedad LoadStylesAndCSSFromMainHtmlDocument hereda opcionalmente los estilos del documento principal que se está renderizando, lo que garantiza la coherencia visual entre los encabezados y el contenido del cuerpo. Esto resulta especialmente útil cuando el documento principal utiliza CSS personalizado que también debe aplicarse a las regiones de encabezado y pie de página.

La propiedad DrawDividerLine añade una regla horizontal profesional para trazar líneas de separación entre el encabezado/pie de página y el contenido principal. Puede personalizar el color de la línea utilizando DrawDividerLineColor para que coincida con los colores de su marca o el tema del documento.

¿Cómo implementar contenido dinámico más allá de los números de página?

El sistema de campos fusionables admite varios valores dinámicos que se rellenan automáticamente durante la renderización:

• {page} - Número de página actual
• {total-pages} - Número final de páginas del documento
• {date} - Fecha actual en formato local
• {time} - Hora actual en formato local
• {html-title} - Contenido de la etiqueta <title> del HTML fuente
• {pdf-title} - Título de metadatos del documento PDF
• {url} - URL de origen al renderizar desde una dirección web

La combinación de estos campos permite diseños de pie de página sofisticados, habituales en documentos empresariales. Los departamentos jurídicos suelen necesitar pies de página con el título del documento, la fecha y el número de páginas. Los informes financieros pueden necesitar marcas de tiempo para cumplir la normativa. Los campos fusionables cumplen estos requisitos sin necesidad de código personalizado para cada tipo de documento.

Para un contenido verdaderamente dinámico -valores determinados en tiempo de ejecución- puede construir la cadena de fragmentos HTML con valores interpolados antes de asignarla a la propiedad HtmlFragment. Este enfoque permite incluir cabeceras con valores recuperados de bases de datos, información del usuario o datos calculados:

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
}

Tenga en cuenta las llaves dobles alrededor de {page} al utilizar la interpolación de cadenas; de este modo se escapan los caracteres de las llaves para que el campo fusionable se conserve en la cadena final. Este patrón funciona de forma similar a cómo se manejan los parámetros object sender, EventArgs e en el código dirigido por eventos, manteniendo intactos los marcadores de posición del framework e inyectando tus propios valores.

Introducción a IronPDF

Implementar encabezados y pies de página en sus documentos PDF le llevará sólo unos minutos con IronPDF. Instale la biblioteca a través de NuGet Package Manager:

Install-Package IronPdf

Cómo Añadir Encabezado y Pie de Página en PDF Usando iTextSharp y IronPDF en C# con Ejemplo: Imagen 10 - Instalación

O utilizando la CLI de .NET:

dotnet add package IronPDF

dotnet add package IronPDF

La biblioteca no requiere dependencias externas y funciona inmediatamente después de su instalación. Comience con la documentación Cómo empezar para explorar toda la gama de funciones de generación y manipulación de PDF.

Pruebe IronPDF con una versión de prueba gratuita para probar estas implementaciones de encabezado y pie de página en sus propios proyectos. Para los despliegues de producción, las opciones de licencia se adaptan a todo, desde desarrolladores individuales hasta equipos empresariales.

Cómo añadir encabezado y pie de página en PDF usando iTextSharp y IronPDF en C# con ejemplo: Imagen 11 - Licencias

Conclusión

Añadir encabezados y pies de página a documentos PDF en C# va de lo sencillo a lo complejo, dependiendo de la biblioteca que elija. Mientras que iText 7 proporciona un control de bajo nivel a través de controladores de eventos como public override void OnEndPage y operaciones de lienzo utilizando patrones PdfWriter writer, PdfContentByte cb, IronPDF ofrece la misma funcionalidad a través de una API intuitiva que aprovecha conceptos HTML y CSS familiares.

Para los desarrolladores que priorizan la implementación rápida y el código mantenible, el enfoque de IronPDF reduce la implementación de encabezados y pies de página de docenas de líneas, incluidos los manejadores public class PdfFooter, las configuraciones de celdas PdfPCell y las nuevas estructuras PdfPTable a solo unas pocas asignaciones de propiedades. La opción de estilización basada en HTML abre posibilidades para diseños sofisticados sin tener que aprender sistemas de coordenadas específicos de PDF ni gestionar cabeceras de disposición de contenidos.

Ya se trate de generar facturas con la marca de la empresa, informes con navegación por páginas o contratos que requieran marcas de tiempo, los encabezados y pies de página profesionales establecen la credibilidad del documento. La documentación de IronPDF proporciona ejemplos adicionales y material de referencia de la API para implementar estas y otras funciones de PDF en sus aplicaciones .NET.