Générateur de PDF .NET

Traduit par Bit Miracle. Article original de Sergey Bobrovsky

Mis à jour le 3 juillet 2026

Avec l’aide de Docotic.Pdf, vous pouvez générer des documents PDF en les composant à partir d’éléments structurels tels que des pages, des conteneurs, des segments de texte, des images, des liens, des en-têtes, des pieds de page, des tableaux, des listes, et plus encore. Ces éléments sont disponibles via l’API Layout de haut niveau, fournie par le complément gratuit Layout pour Docotic.Pdf. L’API prend également en charge des composants personnalisés réutilisables.

L’API Layout vous permet de définir des documents entièrement en code C# ou VB.NET selon une approche fluide. D’après cette description, le générateur PDF fourni par le complément peut produire des documents à la mise en page arbitrairement complexe, allant de pages simples à des rapports PDF très structurés.

Bases de la génération de PDF

Pour générer des documents PDF à l’aide de l’API Layout, vous avez besoin du complément gratuit Layout. Une clé de licence est également requise pour utiliser la bibliothèque principale et les compléments. Vous pouvez utiliser une clé d’essai gratuite ou une clé achetée.

Installer le complément

La méthode recommandée consiste à installer le complément depuis NuGet.

Install-Package BitMiracle.Docotic.Pdf.Layout

Le gestionnaire de packages gérera automatiquement les dépendances.

Si vous préférez installer le complément manuellement, commencez par télécharger l’archive ZIP contenant les binaires de Docotic.Pdf. Décompressez l’archive et ajoutez des références aux DLL suivantes :

• BitMiracle.Docotic.Pdf.dll
• BitMiracle.Docotic.Pdf.Layout.dll depuis le sous-dossier Layout add-on.

Obtenir une clé de licence

Pour essayer la bibliothèque, demandez une clé de licence gratuite à durée limitée en remplissant le formulaire sur la page de téléchargement de Docotic.Pdf. Si vous avez déjà acheté une licence, utilisez le code qui vous a été fourni après l’achat.

Le complément Layout est gratuit et ne nécessite pas de licence supplémentaire. Vous pouvez utiliser l’API Layout avec la licence Docotic.Pdf que vous possédez déjà.

Bonjour, monde ! avec l’API Layout

Voici un exemple de code qui utilise l’API pour générer un PDF avec la phrase classique « Hello, world! » :

BitMiracle.Docotic.LicenseManager.AddLicenseData("PUT-LICENSE-HERE");

PdfDocumentBuilder.Create().Generate("hello.pdf", doc => doc.Pages(pages =>
{
    pages.Content().Text("Hello, world!");
}));

Ce code produit un PDF d’une seule page avec le texte dans le coin supérieur gauche.

Comprendre l’exemple de code

L’exemple commence par l’ajout d’une clé de licence. Sans licence, la bibliothèque Docotic.Pdf ne générera rien. Le code qui produit le PDF commence à la ligne suivante.

Le code crée une instance du générateur de document en appelant la méthode statique PdfDocumentBuilder.Create(). L’appel à la méthode Generate lance le processus de génération du PDF. Cette méthode accepte deux paramètres : le nom du fichier à produire et un délégué de type Action<Document>. Le complément génère hello.pdf comme résultat de l’appel à Generate.

Pour savoir quelle mise en page le PDF doit avoir, le générateur de document appelle le délégué avec une instance de Document. Le code du délégué compose le contenu du document. Dans cet exemple, le délégué utilise la méthode Pages pour fournir au générateur un autre délégué qui définit la mise en page des pages du document.

Le générateur appelle le délégué fourni à la méthode Pages avec une instance de PageLayout. Cette instance représente une ou plusieurs pages dans le document. Le nombre exact de pages dépend du contenu ajouté.

Le délégué de page appelle la méthode Content pour accéder au conteneur de mise en page du contenu principal de la ou des pages. Un appel chaîné à la méthode Text du conteneur ajoute le segment de texte d’exemple à la page. Consultez le guide sur les conteneurs de mise en page pour une explication détaillée de leur fonctionnement.

Le générateur de document répartit automatiquement le contenu sur plusieurs pages, en créant exactement autant de pages que nécessaire pour contenir toutes les données ajoutées au conteneur de mise en page du contenu principal. Dans cet exemple, une seule page suffit, donc la sortie contient exactement une page.

Tâches courantes au-delà de l’exemple de base

Le code d’exemple crée d’abord une instance de PdfDocumentBuilder, puis appelle la méthode Generate pour produire un PDF. Vous pouvez configurer le générateur avant qu’il ne commence à produire le PDF.

Par exemple, vous pouvez produire un PDF chiffré en fournissant un gestionnaire de chiffrement au générateur. Vous pouvez également spécifier des métadonnées que le générateur inclura dans le document produit. Pour plus de détails sur la manière de personnaliser le générateur, consultez l’article séparé.

Le code d’exemple n’utilise que le conteneur de mise en page de l’emplacement de contenu principal, mais d’autres emplacements de contenu sont également disponibles. Voici la liste complète des méthodes PageLayout pour accéder aux emplacements de contenu :

• Background() - retourne la couche d’arrière-plan, qui est recouverte par d’autres contenus.
• Header() - retourne l’en-tête commun à toutes les pages.
• Content() - retourne l’emplacement du contenu principal de la page.
• Footer() - retourne le pied de page commun à toutes les pages.
• Foreground() - retourne la couche de premier plan, qui apparaît au-dessus des autres contenus.

Seul le contenu de l’emplacement principal influence le nombre de pages du PDF généré. Le générateur de document répète tous les emplacements autres que celui fourni par Content() sur chaque page. Pour plus d’informations sur les emplacements de contenu, consultez l’article sur la mise en page.

De nombreux documents utilisent des mises en page différentes selon les pages. Par exemple, la première page peut avoir une conception de type couverture, tandis que les pages suivantes utilisent une mise en page plus simple. Certains documents incluent des pages spéciales pour les tableaux ou appliquent des arrière-plans différents selon la section. Pour générer de tels documents avec Docotic.Pdf et le complément Layout, appelez plusieurs fois la méthode Document.Pages. Vous pouvez trouver un exemple fonctionnel dans notre dépôt d’exemples.

Organiser le code

Pour un code court, comme dans l’exemple, il est acceptable d’enchaîner les appels et d’utiliser des lambdas imbriquées. Lorsque vous construisez quelque chose de plus grand, il peut être plus pratique de répartir le code dans des méthodes séparées. Cela rend le code plus facile à lire et à maintenir.

Voici à quoi ressemble l’exemple Bonjour, monde ! lorsque son code est réparti en méthodes.

public void GeneratePdf()
{
    BitMiracle.Docotic.LicenseManager.AddLicenseData("PUT-LICENSE-HERE");

    PdfDocumentBuilder.Create().Generate("hello.pdf", BuildDocument);
}

private void BuildDocument(Document doc)
{
    doc.Pages(BuildPages);
}

private void BuildPages(PageLayout pages)
{
    pages.Content().Text("Hello, world!");
}

Pourquoi générer des PDF avec l’API Layout de Docotic.Pdf

L’API Layout est une manière moderne et adaptée aux développeurs de générer des PDF à partir de blocs de construction composables, sans avoir besoin de comprendre les détails internes du format PDF. Elle met en page les PDF avec de hautes performances et un comportement déterministe et prévisible. Vous pouvez utiliser l’API dans des scénarios de génération de documents à grand volume.

L’API est disponible lorsque vous utilisez Docotic.Pdf avec le complément gratuit Layout. Docotic.Pdf et le complément Layout sont tous deux des DLL de code managé à 100 %, sans blocs de code unsafe. L’API Layout est implémentée sans dépendances externes tierces, comme un navigateur ou des binaires Skia, ce qui en fait une solution légère, peu coûteuse en ressources et facile à déployer et à maintenir.

Vue d’ensemble de l’API

L’API Layout est une API fluide et agréable à utiliser. Vous décrivez entièrement en code la mise en page de votre document à l’aide d’éléments de mise en page flexibles, et le générateur fait circuler votre contenu, le pagine automatiquement et restitue le résultat en PDF.

Le complément Layout utilise un système de mise en page déclaratif basé sur le flux. Ses éléments de mise en page incluent des listes, des colonnes, des lignes, des tableaux, des images, des segments de texte, des en-têtes et pieds de page, des conteneurs, et plus encore. Au lieu de placer manuellement les éléments à des coordonnées exactes, vous décrivez leur comportement attendu. Le générateur de document calcule ensuite la mise en page finale et crée le PDF.

Le système de mise en page basé sur le flux garantit que la mise en page s’adapte à la taille de la page et au contenu. Grâce à ce système, le complément excelle dans les mises en page complexes, structurées et fondées sur des règles. Vous pouvez imbriquer différents types de conteneurs et construire des structures sophistiquées sans sacrifier la lisibilité.

Lorsque vous utilisez l’API Layout, vous pouvez enchaîner la plupart des appels. Cela conduit à un code plus compact et plus expressif qu’avec les API traditionnelles. L’ordre des appels dans une chaîne est important. Tout est fortement typé, ce qui apporte une sécurité à la compilation et rend le code plus facile à refactoriser. Vous pouvez également écrire des tests unitaires pour le code qui utilise l’API Layout.

Pour rendre encore plus concise l’implémentation de votre mise en page, vous pouvez étendre l’API avec vos propres méthodes et construire autour d’elle un DSL propre et expressif.

Pour plus d’informations sur le positionnement et la création de DSL, consultez l’article expliquant comment contrôler la taille, la position, l’alignement et le comportement de rendu des conteneurs.

Versions de .NET et prise en charge des plateformes

Vous pouvez utiliser l’API Layout dans des projets ciblant .NET Standard 2.1 et des frameworks plus récents. Autrement dit, le complément Layout est compatible avec .NET 5 à .NET 10. De plus, .NET Core 3.0+ est pris en charge.

Vous pouvez générer des PDF avec l’API Layout dans ASP.NET Core, les applications MAUI, Unity, Xamarin et les applications console. Docotic.Pdf avec le complément Layout peut produire des PDF sous Windows, macOS et Linux.

Plates-formes cloud et images Docker

Docotic.Pdf avec le complément Layout peut s’exécuter dans des environnements cloud Azure et AWS, y compris dans des configurations serverless. La bibliothèque et le complément prennent entièrement en charge les changements dynamiques de matériel, l’auto-élasticité et d’autres fonctionnalités d’exécution natives du cloud.

Dans la plupart des scénarios cloud, une licence non liée est requise. La FAQ sur les licences explique comment choisir la licence appropriée pour les applications cloud.

L’API Layout fonctionne simplement dans les conteneurs Docker. Vous n’avez besoin d’aucune configuration spéciale pour générer des PDF lors de l’exécution de la bibliothèque et du complément Layout dans un conteneur.

Ajouter du texte aux fichiers PDF

Le texte est une partie fondamentale de tout document PDF. Vous pouvez utiliser les méthodes Text de la classe LayoutContainer pour ajouter du texte à un emplacement de contenu.

Segments de texte

Dans l’exemple Bonjour, monde, j’ai utilisé la surcharge LayoutContainer.Text(string) pour ajouter du texte au contenu principal de la page. Voyons maintenant une autre surcharge de la méthode Text.

public static void GenerateTextPdf()
{
    PdfDocumentBuilder.Create().Generate("text-spans.pdf", doc => doc.Pages(pages =>
    {
        pages.Content().Text(AddTextSpans);
    }));
}

private static void AddTextSpans(TextContainer text)
{
    text.Line("About VB.NET")
        .Style(t => t.Strong);

    text.Span("VB.NET is a multi-paradigm, object-oriented language ");
    text.Span("that runs on .NET, Mono, and the ");
    text.Hyperlink(
        ".NET Framework",
        new Uri("https://dotnet.microsoft.com/download/dotnet-framework"));
    text.Line(".");

    text.Span("Released by Microsoft in 2002, ");
    text.Line("it continues the lineage of the original Visual Basic language.");
}

Ce code utilise les méthodes Span et Line de la classe TextContainer pour ajouter du texte à la ligne en cours. La méthode Line termine en plus la ligne courante. Le code d’exemple utilise également la méthode Hyperlink pour associer un lien vers une ressource externe à un segment de texte spécifique.

Remarquez comment le code d’exemple applique un formatage fort à la première ligne à l’aide de la méthode Style. Explorons le concept des styles de texte plus en détail.

Styles de texte

Les styles de texte vous permettent de personnaliser l’apparence du texte. La classe TextStyle fournit des méthodes pour modifier la taille de police, l’espacement des lettres, les couleurs et d’autres propriétés du texte. Les objets TextStyle sont immuables, donc chaque appel de méthode produit une nouvelle instance de style. Vous pouvez appliquer des styles de texte à différents niveaux de mise en page.

PdfDocumentBuilder.Create().Generate("text-styles.pdf", doc =>
{
    doc.Pages(pages =>
    {
        pages.TextStyle(TextStyle.Parent.FontSize(30));

        pages.Content()
            .TextStyle(TextStyle.Parent.FontColor(new PdfRgbColor(0, 0, 255)))
            .Text(text =>
            {
                text.Span("Hello,");

                text.Span("World!")
                    .Style(TextStyle.Parent.Underline());
            });
    });
});

La propriété TextStyle.Parent retourne un style spécial dans lequel toutes les propriétés de texte sont indéfinies. Dans l’exemple ci-dessus, le code dessine « Hello, World! » en bleu, avec le deuxième mot souligné, en utilisant une taille de police de 30 points.

Cela se produit parce que le code :

• définit la taille de police à 30 points au niveau de la page,
• définit ensuite la couleur du texte en bleu pour l’emplacement de contenu principal,
• applique ensuite le style souligné au dernier segment de texte.

Chaque style suivant hérite des précédents via la propriété TextStyle.Parent.

En utilisant les méthodes de la classe TextStyle, vous pouvez notamment changer la direction du texte de droite à gauche. Consultez un autre exemple d’utilisation de l’héritage des styles de texte dans notre dépôt d’exemples.

Typographie

La classe TextStyle permet de personnaliser toutes les propriétés de texte, à l’exception de la police associée. Pour modifier la police par défaut, utilisez les méthodes Document.TextStyleWithFont pour créer un style de texte basé sur une police spécifique. Vous pouvez utiliser une police installée dans le système d’exploitation ou en charger une depuis un fichier ou un flux.

Après avoir créé un style basé sur une police, vous pouvez appliquer des propriétés optionnelles supplémentaires puis utiliser le style obtenu sur un segment de texte. Cet exemple C# montre comment utiliser une police système.

PdfDocumentBuilder.Create().Generate("text-style-with-font.pdf", doc =>
{
    var font = SystemFont.Family("Calibri");
    var style = doc.TextStyleWithFont(font).FontSize(30);

    doc.Pages(pages =>
    {
        pages.Content().Text(text =>
        {
            text.Span("Hello,");

            text.Span("World!")
                .Style(style);
        });
    });
});

La méthode TextStyleWithFont inclut un paramètre facultatif qui spécifie comment la police doit être intégrée dans le document généré. Par défaut, la bibliothèque :

• intègre les glyphes utilisés pour les polices TrueType/OpenType,
• intègre tous les glyphes pour les polices Type1 et CFF,
• n’intègre pas les glyphes pour les polices PDF intégrées (polices Base14).

Grâce à ces valeurs par défaut, les documents qui utilisent des polices TrueType et OpenType peuvent rester de taille réduite même lorsque de grandes polices sont utilisées. Vous pouvez également spécifier un chargeur de police personnalisé, des polices de secours et un gestionnaire pour les glyphes manquants. Consultez le code d’exemple dans notre dépôt d’exemples pour plus de détails sur la gestion des polices dans les documents PDF.

L’API Layout fournit une collection de styles prédéfinis, que vous pouvez accéder et modifier via la classe Typography.

PdfDocumentBuilder.Create().Generate("typography.pdf", doc =>
{
    doc.Typography(t =>
    {
        var fontsPath = Environment.GetFolderPath(Environment.SpecialFolder.Fonts);
        var arialFont = new FileInfo(Path.Combine(fontsPath, "arial.ttf"));

        t.Document = doc.TextStyleWithFont(arialFont);
        t.Header = t.Parent.FontSize(20).FontColor(new PdfGrayColor(20));
        t.Footer = t.Footnote;
    });

    doc.Pages(pages =>
    {
        pages.Header().AlignCenter().Text("Header");

        pages.Content().Text(t =>
        {
            t.Line("Title").Style(t => t.Title);
            t.Line("Heading 1").Style(t => t.Heading1);
            t.Line("Regular");
        });

        pages.Footer()
            .Height(20)
            .AlignCenter()
            .Text(t => t.CurrentPageNumber());
    });
});

Je recommande de remplacer les styles prédéfinis en configurant la typographie pour l’ensemble du document, bien que cela ne soit pas obligatoire et que vous puissiez toujours appliquer des styles de texte au niveau du segment de texte.

Avec la classe Typography, vous n’avez pas besoin de stocker des références de styles de texte dans des variables. À la place, vous enregistrez les styles requis à l’aide des méthodes Document.Typography, puis vous y accédez via les propriétés de l’objet Typography. Consultez l’exemple Typography pour voir comment utiliser les styles de texte prédéfinis et personnalisés lors de la génération de documents PDF.

Travailler avec les en-têtes et les pieds de page

De nombreux documents PDF réels, comme les rapports ou les factures, incluent des en-têtes et des pieds de page. Cette section montre comment ajouter les deux à un PDF.

public static void GeneratePdfWithHeaderAndFooter()
{
    PdfDocumentBuilder.Create()
        .Generate("header-footer.pdf", doc => doc.Pages(pages =>
    {
        pages.Size(PdfPaperSize.A6).Margin(10);

        BuildPagesHeader(pages.Header());
        BuildPagesFooter(pages.Footer());

        pages.Content().Text("Hello, world!");
    }));
}

public static void BuildPagesHeader(LayoutContainer header)
{
    header.TextStyle(TextStyle.Parent.FontSize(8))
        .AlignRight()
        .Text(t =>
        {
            t.Line($"Created by: {Environment.UserName}");
            t.Line($"Date: {DateTime.Now}");
        });
}

public static void BuildPagesFooter(LayoutContainer footer)
{
    footer.AlignRight().Text(text =>
    {
        text.Style(t => t.Parent.FontColor(new PdfRgbColor(255, 0, 0)));

        text.CurrentPageNumber();
        text.Span(" / ");
        text.PageCount();
    });
}

La méthode BuildPagesHeader définit une taille de police plus petite pour le texte de l’en-tête. Elle utilise deux lignes pour le contenu de l’en-tête : une avec le nom de l’utilisateur actuel et une autre avec la date actuelle. Le texte est aligné à droite.

Remarquez que le code ne spécifie aucune taille explicite pour l’en-tête. Il occupe toute la largeur de la page moins les marges gauche et droite, et sa hauteur dépend de la hauteur des lignes de texte.

La méthode BuildPagesFooter montre comment placer le numéro de page courant dans le pied de page PDF. La bibliothèque calcule automatiquement le numéro de page courant et le nombre total de pages. Vous pouvez accéder à ces valeurs à l’aide des méthodes CurrentPageNumber et PageCount d’un objet TextContainer.

L’API Layout fournit également un moyen de formater les numéros de page. Par exemple, vous pouvez afficher des numéros de page hexadécimaux comme ceci :

text.CurrentPageNumber().Format(p => "0x" + p?.ToString("x2"));

Notre dépôt d’exemples contient un autre exemple d’ajout d’un en-tête et d’un pied de page à un PDF. Cet exemple formate les numéros de page en chiffres romains.

Insérer des images

Comme le dit l’adage, une seule image peut remplacer beaucoup de mots. Dans les devis ou les reçus, vous inclurez souvent le logo de votre entreprise ou une autre image importante. Pour cet exemple, j’utiliserai une image simple et esthétique.

Pour utiliser une image, vous devez d’abord l’ajouter au document. La bibliothèque peut charger des images depuis un fichier ou un flux. Seuls les formats raster sont pris en charge : PNG, JPEG, JPEG 2000, BMP, GIF et TIFF.

Une fois que vous avez un objet Image, vous pouvez le définir comme contenu d’un ou plusieurs conteneurs de mise en page en appelant la méthode Image du conteneur. Vous pouvez mettre à l’échelle, faire pivoter, ajouter du remplissage et disposer l’image comme n’importe quel autre contenu.

PdfDocumentBuilder.Create().Generate("image-with-text.pdf", doc =>
{
    var imageFile = new FileInfo("red-flowers-at-butterfly-world.jpg");
    var image = doc.Image(imageFile);

    doc.Pages(pages =>
    {
        pages.Size(PdfPaperSize.A6);
        pages.Content().Column(c =>
        {
            c.Spacing(20);

            c.Item()
                .AlignCenter()
                .Text("Hello, world!")
                .FontSize(20);

            c.Item()
                .AlignCenter()
                .MaxWidth(200)
                .Image(image);
        });
    });
});

Le code d’exemple utilise à la fois du texte et une image dans l’emplacement de contenu principal. Cependant, un conteneur de mise en page ne peut contenir que du texte ou qu’une image. Pour inclure les deux dans l’emplacement de contenu principal de la page, vous avez besoin d’un conteneur composé.

J’utilise un conteneur Column pour placer le texte et l’image verticalement, l’un après l’autre. La méthode Item du conteneur colonne fournit un sous-conteneur. Un appel à Item crée un conteneur pour le texte, et un autre crée un conteneur pour l’image. Le conteneur composé avec tous ses sous-conteneurs devient le contenu principal.

Pour exécuter le code d’exemple, téléchargez l’image de fleurs depuis notre dépôt d’exemples et placez-la dans le répertoire de travail de votre application.

Images en ligne

Si vous disposez seulement d’une URL d’image plutôt que d’un fichier, téléchargez l’image dans un flux mémoire et créez un objet Image à partir de ce flux. L’exemple suivant montre comment utiliser des images en ligne avec l’API Layout.

public static async Task AddImageWithTextFromUrl()
{
    using var http = new HttpClient();
    using var stream = await http.GetStreamAsync("url/to/image");

    var memoryStream = new MemoryStream();
    await stream.CopyToAsync(memoryStream);
    memoryStream.Position = 0;

    PdfDocumentBuilder.Create().Generate("online-image-with-text.pdf", doc =>
    {
        var image = doc.Image(memoryStream);

        doc.Pages(pages =>
        {
            pages.Size(PdfPaperSize.A6);
            pages.Content().Column(c =>
            {
                c.Spacing(20);

                c.Item()
                    .AlignCenter()
                    .Text("Hello, world!")
                    .FontSize(20);

                c.Item()
                    .AlignCenter()
                    .MaxWidth(200)
                    .Image(image);
            });
        });
    });
}

Comme la méthode effectue un travail asynchrone (téléchargement d’une image depuis une URL), elle est déclarée async Task plutôt que void. Les appelants doivent l’await pour garantir que la génération du PDF se termine correctement. Dans votre propre code, une méthode similaire peut aussi retourner une valeur, auquel cas elle serait déclarée async Task<TResult>.

Créer des listes

Qu’est-ce qu’une liste ? Vous pouvez la voir comme un groupe d’éléments numérotés écrits les uns sous les autres. L’API Layout ne fournit pas de type de conteneur spécial pour les listes, mais il est facile d’en implémenter une en utilisant d’autres conteneurs composés.

var dayNames = DateTimeFormatInfo.InvariantInfo.DayNames;
var dayNamesSpain = DateTimeFormatInfo.GetInstance(new CultureInfo("es-ES")).DayNames;

PdfDocumentBuilder.Create().Generate("list.pdf", doc => doc.Pages(pages =>
{
    pages.Size(PdfPaperSize.A6);
    pages.Content().Column(column =>
    {
        for (int i = 0; i < dayNames.Length; i++)
        {
            column.Item().Row(row =>
            {
                row.Spacing(5);
                row.AutoItem().Text($"{i + 1}.");
                row.RelativeItem().Text(t =>
                {
                    t.Line(dayNames[i]);
                    t.Line($"In Spain they call it {dayNamesSpain[i]}");
                });
            });
        }
    });
}));

Le code d’exemple crée la liste sous forme de colonne de lignes. Chaque ligne contient deux éléments : le premier (à gauche) contient le numéro de l’élément, et le second (à droite) contient le texte de l’élément. Le code définit explicitement l’espacement entre les éléments de chaque ligne.

Pour disposer les éléments, le conteneur Row doit soit avoir la taille de chaque élément spécifiée explicitement, soit la calculer. Dans cet exemple, les méthodes AutoItem et RelativeItem sont utilisées. En conséquence, le conteneur de ligne calcule la largeur requise pour le premier élément, puis utilise la largeur disponible restante pour le second.

En utilisant cette approche et en ajustant l’apparence des lignes selon les besoins, vous pouvez créer une liste qui correspond au mieux à la mise en page et au style de votre document.

Créer des tableaux

De nombreux documents PDF contiennent des tableaux, ce qui n’a rien d’étonnant puisque les tableaux améliorent la clarté et l’organisation des données. Cette section montre comment créer un tableau dans un PDF à l’aide de l’API Layout.

public static void AddTable()
{
    PdfDocumentBuilder.Create().Generate("table.pdf", doc => doc.Pages(pages =>
    {
        pages.Size(PdfPaperSize.A6);

        var color = new PdfGrayColor(75);
        pages.Content().Padding(20).Table(t =>
        {
            t.Columns(c =>
            {
                c.RelativeColumn(4);
                c.RelativeColumn(1);
                c.RelativeColumn(4);
            });

            t.Header(h =>
            {
                h.Cell().Background(color).Text("Month");
                h.Cell().Background(color).Text("Days");
                h.Cell().Background(color).Text("First Day");
            });

            var year = DateTime.Now.Year;
            for (int yearDiff = 0; yearDiff < 4; yearDiff++)
            {
                for (int i = 11; i >= 0; i--)
                {
                    var stats = GetMonthStats(year - yearDiff, i);

                    t.Cell().Text(stats.Item1);
                    t.Cell().Text(stats.Item2);
                    t.Cell().Text(stats.Item3);
                }
            }
        });
    }));
}

private static (string, string, string) GetMonthStats(int year, int monthIndex)
{
    return (
        $"{DateTimeFormatInfo.InvariantInfo.MonthNames[monthIndex]} {year}",
        DateTime.DaysInMonth(year, monthIndex + 1).ToString(),
        new DateTime(year, monthIndex + 1, 1).DayOfWeek.ToString()
    );
}

Le code d’exemple crée un tableau simple qui affiche des informations de base sur les mois de l’année en cours et des trois années précédentes. Le code définit trois colonnes avec des largeurs relatives. Les colonnes de gauche et de droite sont quatre fois plus larges que la colonne du milieu.

Le code définit également l’en-tête du tableau en ajoutant des cellules d’en-tête et en spécifiant le texte et la couleur d’arrière-plan de chaque cellule. Lorsqu’un tableau ne tient pas sur une seule page, l’en-tête est répété sur chaque page occupée par le tableau. Vous pouvez observer ce comportement dans le PDF généré par le code d’exemple.

Deux boucles simples sont utilisées pour construire les lignes. La boucle externe parcourt les années, et la boucle interne parcourt les mois en ordre inverse. La boucle interne récupère des informations sur chaque mois puis ajoute trois cellules pour former une ligne.

Pour plus de détails, vous pouvez lire l’article qui explique en profondeur les fonctionnalités du conteneur Table.

Créer des liens PDF internes

Les documents PDF prennent en charge les liens internes qui permettent aux lecteurs d’accéder à un autre emplacement dans le même fichier. Dans une visionneuse PDF, ces liens apparaissent comme des éléments de texte ou d’image cliquables. Ils fonctionnent comme des liens hypertexte, mais au lieu de pointer vers un site web externe, ils naviguent à l’intérieur du document lui-même.

De nombreux documents PDF utilisent des liens internes pour les signets ou une table des matières, ce qui aide les lecteurs à passer rapidement d’une section à l’autre. Voici comment vous pouvez ajouter un lien vers une section du document à l’aide de l’API Layout :

PdfDocumentBuilder.Create().Generate("link.pdf", doc =>
{
    doc.Pages(pages =>
    {
        pages.Content().Column(c =>
        {
            const string SectionName = "Chapter 1";
            c.Item().SectionLink(SectionName).Text("Link");

            c.Item().PageBreak();

            c.Item().Section(SectionName).Text("Target");
        });
    });
});

Le code d’exemple fait du texte de la première page un lien vers la section portant le nom spécifié. Il le fait en appelant la méthode SectionLink sur le conteneur de mise en page qui contient le texte. La section peut exister ou non à ce moment-là. Le texte devient cliquable dans une visionneuse PDF.

Le code marque ensuite le texte de la deuxième page comme début de la section portant le même nom. Son apparence et son comportement ne changent pas, mais il devient la cible du lien sur la première page. Cela est fait en appelant la méthode Section sur le conteneur de mise en page correspondant.

Dans cet exemple, le lien et sa cible sont tous deux des segments de texte, mais vous pouvez créer des sections et des liens sur n’importe quel conteneur de mise en page. Il peut s’agir d’un conteneur avec une image, d’un conteneur de tableau ou d’un conteneur que vous construisez vous-même.

Voir un exemple de création d’une table des matières PDF dans notre dépôt d’exemples.

Concevoir des mises en page PDF complexes

L’API Layout fournit une variété de conteneurs de mise en page que vous pouvez combiner pour produire des documents PDF arbitrairement complexes. Vous pouvez également étendre l’API avec vos propres composants personnalisés.

Les exemples de cette page sont volontairement simples, conçus pour créer des documents directs afin que vous puissiez vous concentrer sur les idées fondamentales sans vous perdre dans les détails. Si vous souhaitez voir comment différents conteneurs peuvent être combinés pour générer un PDF plus complexe, consultez l’exemple correspondant dans notre dépôt d’exemples sur GitHub.

En plus d’utiliser les conteneurs intégrés, vous pouvez définir et utiliser des composants de mise en page personnalisés. Ces composants sont particulièrement utiles lorsque vous souhaitez qu’une seule classe encapsule à la fois les données et la logique de mise en page. Tout garder au même endroit rend le composant plus facile à comprendre, à modifier et à réutiliser, tout en vous offrant un moyen flexible de gérer des mises en page complexes.

Pour créer un composant de mise en page personnalisé, implémentez l’interface ILayoutComponent dans votre classe. Lors de la génération d’un PDF, la bibliothèque appelle la méthode Compose de l’interface et fournit un objet LayoutContext. Votre code peut utiliser cet objet pour créer des éléments de mise en page et accéder aux informations sur le document en cours de génération.

Pour ajouter un composant de mise en page personnalisé à votre mise en page, appelez la méthode Component de la classe LayoutContainer. En termes de dimensionnement et de positionnement, un composant personnalisé se comporte comme du texte ou des images.

Pour un exemple d’implémentation d’un composant personnalisé avec l’interface ILayoutComponent, consultez l’exemple Composants de mise en page.

Autres façons de créer des PDF

Docotic.Pdf propose plusieurs façons de créer des PDF, chacune adaptée à des scénarios différents. Cette section explique quand s’appuyer sur l’API Layout et quand d’autres approches peuvent mieux vous convenir.

Quand privilégier l’API Layout

L’API Layout de Docotic.Pdf est un moyen puissant de générer des PDF à partir de mises en page structurées. Elle vous permet de construire des documents en composant du texte, des images, des conteneurs et des tableaux en structures imbriquées arbitrairement complexes. Le processus de génération est rapide, consomme une quantité raisonnable de mémoire et se comporte de manière prévisible.

Docotic.Pdf et le complément Layout forment un ensemble léger et entièrement autonome. L’API ne nécessite pas de bibliothèques externes ni de navigateurs pour générer des PDF. Cela en fait un bon choix pour les microservices .NET, les applications cloud, en particulier serverless, et d’autres environnements où l’empreinte compte.

Comme la mise en page du document est définie en code, vous pouvez tester unitairement n’importe quelle partie. La logique de mise en page peut être réutilisée comme n’importe quel autre code, et vous pouvez encapsuler à la fois les données et le comportement de mise en page dans des composants personnalisés.

Alternatives à l’API Layout

Un article dédié fournit une comparaison détaillée de toutes les façons de créer des PDF avec Docotic.Pdf. Voici quelques-unes des alternatives les plus couramment utilisées.

• Conversion HTML en PDF
  Réutilise des modèles HTML/CSS existants. Choisissez l’approche HTML vers PDF lorsque votre équipe produit déjà des documents en HTML/CSS et que vous avez besoin de versions PDF de ces documents.

• Génération de PDF bas niveau
  Offre le contrôle maximal disponible dans la bibliothèque sur la structure et le contenu du PDF. Choisissez cette approche lorsque vous avez besoin d’un positionnement au pixel près ou de graphiques vectoriels complexes. Cette approche est recommandée pour les scénarios critiques en performances ou lorsque l’empreinte la plus réduite possible est requise.

• Génération de PDF basée sur des modèles
  Offre une manière rapide et prévisible de remplir des documents sans concevoir ni agencer leurs éléments. Choisissez cette approche lorsque vous disposez d’une structure PDF prédéfinie, comme des modèles approuvés ou soumis à des contraintes de conformité, et que vous avez seulement besoin de modifier des champs de texte, remplacer des espaces réservés, joindre des documents associés et effectuer des tâches similaires.

• Fusion et composition de PDF
  Vous permet de créer un PDF à partir de fragments existants plutôt que de le construire à partir de zéro. Choisissez cette approche lorsque vous avez des images, des pages numérisées ou d’autres PDF à combiner en un seul fichier.

Comparaison avec d’autres solutions de génération de PDF

Cette section contient deux tableaux de comparaison : l’un avec les points clés à retenir et l’autre avec des informations détaillées et structurées sur la manière dont Docotic.Pdf avec le complément Layout se compare à d’autres solutions populaires de génération de PDF.

Points clés de la comparaison

Il existe de bonnes options pour générer des PDF, y compris des options gratuites. Cependant, les capacités comme la signature, le chiffrement ou la fusion de documents varient, ce qui peut limiter les outils qui répondent réellement à vos besoins.

Comparaison détaillée

Examinez le tableau pour comprendre le contexte général et tirer vos propres conclusions.

Conclusion

Docotic.Pdf avec le complément Layout fournit un moyen moderne, performant et de haute qualité de générer des PDF en C# et VB.NET. La bibliothèque produit des rapports, relevés, factures et documents similaires. Son API fluide, bien conçue, offre une excellente expérience développeur. Vous pouvez compter sur le support professionnel que Bit Miracle fournit pour Docotic.Pdf et ses compléments.

Contrairement à certaines autres solutions de génération de PDF, Docotic.Pdf est une API PDF complète. La bibliothèque peut signer les PDF générés avec des signatures numériques, y compris des signatures avec LTV. Docotic.Pdf est capable d’utiliser des certificats stockés sur du matériel sécurisé, comme des jetons USB et des cartes à puce. Les modules de sécurité matériels (HSM) basés sur le cloud, tels que Microsoft Azure Key Vault et AWS Key Management Service (KMS), sont également pris en charge.

Avec Docotic.Pdf, vous pouvez joindre des documents d’accompagnement, tels que des feuilles de calcul ou des notes vocales, aux PDF générés. Pour afficher des documents sur une page web ou dans une interface similaire, vous pouvez créer des images miniatures à partir d’une ou plusieurs de leurs pages.

Étapes suivantes :

• Explorez les exemples de code pour l’API Layout.
• Comparez la génération de PDF à partir de blocs de construction composables avec d’autres approches de création de PDF.
• Contactez-nous pour toute question, remarque ou cas limite.