Cette page peut contenir du texte traduit automatiquement.

Créer des documents PDF en C# et VB.NET

En tant que développeur .NET, avez-vous besoin de générer des rapports PDF, des factures, des reçus ou d'autres documents ? Utilisez la bibliothèque Docotic.Pdf pour générer des documents PDF dans vos projets .NET Core, .NET Standard ou .NET Framework. Vous pouvez le faire facilement et sans aucune connaissance du format PDF.

Créer des documents PDF en C# et VB.NET

API .NET pour la génération de PDF

Docotic.Pdf est la bibliothèque de code 100% gérée sans dépendances externes. Vous pouvez l'utiliser pour créer des documents PDF sur les environnements cloud Windows, Linux, Amazon et Azure. macOS, iOS, Android et d'autres environnements cloud conviennent également.

La bibliothèque propose différentes manières de générer des documents PDF. Tout d’abord, vous pouvez utiliser l’API de mise en page de haut niveau pour ajouter des en-têtes et des pieds de page, des tableaux, des paragraphes et diviser automatiquement le contenu des pages. L'API de mise en page est disponible dans le module complémentaire gratuit Docotic.Pdf.Layout.

Ou vous pouvez créer des documents PDF basés sur des modèles HTML en utilisant le module complémentaire HTML vers PDF (également gratuit). Lisez l'article Convertir HTML en PDF pour plus de détails.

Et vous pouvez produire des documents PDF à l'aide de l'API de la bibliothèque principale. Il prend en charge tout contenu PDF - texte, images, graphiques vectoriels, formulaires, annotations, signets, couches et autres. Cependant, l'API principale ne prend pas en charge les composants de mise en page de haut niveau, tels que les en-têtes, les tableaux et les sections. Avec la bibliothèque principale, vous devrez mesurer vous-même le contenu et le répartir entre les pages PDF.

Bibliothèque Docotic.Pdf 9.4.17444-dev Module complémentaire de mise en page 9.4.17444-dev Module complémentaire HTML vers PDF 9.4.17444-dev
Tests de régression 14,746 réussis Téléchargements totaux de NuGet 4,394,692

Vous pouvez également utiliser des modules complémentaires avec la bibliothèque principale ensemble. Par exemple, générez le document PDF à l'aide de l'API de mise en page, puis ajoutez plus de contenu avec la bibliothèque principale. Notez que le module complémentaire de mise en page prend en charge .NET Standard 2.1, .NET Core, .NET 5 et les frameworks plus récents. La bibliothèque principale et le module complémentaire HTML vers PDF prennent en charge .NET Standard 2.0, .NET 4.7.2+, .NET Core, .NET 5 et versions ultérieures.

Les modules complémentaires Docotic.Pdf sont disponibles sur NuGet et inclus dans le zip avec binaires de la bibliothèque. Pour essayer la bibliothèque sans restrictions du mode d'évaluation, vous pouvez obtenir la clé de licence gratuite à durée limitée ici.

Créer des documents PDF à l'aide de l'API de mise en page

Cet exemple C# montre comment générer un document PDF en C# à l'aide de l'API de mise en page :

PdfDocumentBuilder
    .Create()
    .Generate("long-text.pdf", doc => doc.Pages(page =>
    {
        string text = File.ReadAllText(@"C# in Depth, Fourth Edition.txt");
        page.Content().Text(text);

        page.Footer().AlignCenter().Text(t => t.CurrentPageNumber());
    }));

Le code convertit un fichier texte en PDF. Il divise le texte long en pages et dessine également les numéros de page dans la zone de pied de page. Vous n'avez pas besoin de calculer la hauteur du texte ni de compter les pages: la bibliothèque s'occupe de ces tâches de routine.

L'API de mise en page est une API fluide. La plupart des appels peuvent être chaînés, vous pouvez donc écrire du code plus compact qu'avec des frameworks «déclaratifs». Examinons l'API plus en détail.

Définir les propriétés du document PDF

La génération de PDF commence par la classe PdfDocumentBuilder. Il vous permet de spécifier les propriétés d'un document PDF généré. Par exemple, vous pouvez définir les métadonnées, le cryptage, la version PDF ou activer l'affichage Web rapide. Voici l’exemple de base C# :

PdfDocumentBuilder
    .Create()
    .Encryption(new PdfStandardEncryptionHandler("owner", "user"))
    .Info(info =>
    {
        info.Author = "Docotic.Pdf library";
        info.Title = "How to create PDF in .NET";
        info.Keywords = "C#, VB.NET";
    })
    .Version(PdfVersion.Pdf16)
    .Generate("result.pdf", doc => doc.Pages(_ => {}));

Cet exemple crée un document PDF vide protégé par mot de passe avec des métadonnées personnalisées et l'enregistre dans un fichier. Vous pouvez également enregistrer le document dans un flux, utilisez simplement la surcharge PdfDocumentBuilder.Generate(Stream, ..).

Lorsque vous configurez un PdfDocumentBuilder, il est temps de remplir le document PDF avec du contenu. L'API de mise en page fournit un objet Document pour enregistrer les ressources communes (typographie, images) et définir le contenu des pages PDF. Vous pouvez configurer un Document dans le deuxième argument des méthodes PdfDocumentBuilder.Generate. Apprenons à configurer des pages PDF.

Définir la mise en page du PDF

Cet exemple C# montre comment créer un document PDF avec des pages A3 en orientation paysage :

PdfDocumentBuilder.Create().Generate("pages.pdf", doc =>
{
    doc.Pages((PageLayout page) =>
    {
        page.Size(PdfPaperSize.A3, PdfPaperOrientation.Landscape)
            .MarginVertical(50)
            .MarginHorizontal(40);

        page.Header().PaddingBottom(30).AlignRight().Text("Hello PDF");

        page.Content().Column(c =>
        {
            c.Item().Text("Page 1");
            c.Item().PageBreak();
            c.Item().Text("Page 2");
        });

        page.Footer().Text(t => t.CurrentPageNumber());
    });
});

La méthode Document.Pages() définit la mise en page d'une ou plusieurs pages. Tout d'abord, l'exemple de code définit les paramètres communs pour toutes les pages : taille, orientation, marges. Vous pouvez également spécifier l'orientation du contenu, le style de texte par défaut ou la couleur d'arrière-plan.

Ensuite, l’exemple génère la mise en page et le contenu. La classe PageLayout fournit des méthodes pour placer le contenu de la page dans les emplacements suivants :

  • Background() - une couche d'arrière-plan recouverte par un autre contenu
  • Header() - un en-tête commun pour toutes les pages
  • Content() - le contenu d'une page principale
  • Footer() - un pied de page commun à toutes les pages
  • Foreground() - une couche de premier plan qui couvre d'autres contenus

Le moteur de mise en page génère des pages en fonction du contenu ajouté au slot PageLayout.Content(). D'autres emplacements sont répétés sur chaque page. Vous pouvez ajouter du contenu aux emplacements à l'aide de la classe LayoutContainer. Il s'agit d'un élément clé de l'API de mise en page, qui vous permet de générer des mises en page, des tableaux, du texte ou des images arbitraires.

L'exemple précédent utilise la méthode LayoutContainer.Column qui empile verticalement le contenu. Cette colonne contient 3 éléments : le morceau de texte pour la première page, le saut de page explicite et le morceau de texte pour la deuxième page.

Il existe également la méthode LayoutContainer.Row. Regardez comment créer des documents PDF multi-colonnes en utilisant des lignes et des colonnes ensemble.

Vous pouvez mélanger différentes mises en page dans un document PDF. Appelez simplement la méthode Document.Pages plusieurs fois. Consultez l'exemple de Paramètres de mise en page PDF sur GitHub pour un exemple.

Ajouter du texte aux documents PDF

Le texte est une partie importante des documents PDF. Vous pouvez utiliser les méthodes LayoutContainer.Text pour ajouter du texte. Plus tôt, vous avez vu des cas d'utilisation de la surcharge LayoutContainer.Text(string). Regardons une autre surcharge de cette méthode :

PdfDocumentBuilder.Create().Generate("text.pdf", doc =>
{
    doc.Pages(p => p.Content().Text(text =>
    {
        text.Span("VB.NET").Style(t => t.Strong);
        text.Span(" is a multi-paradigm, object-oriented programming language, implemented on.NET, Mono, and the ");
        text.Hyperlink(".NET Framework", new Uri("https://dotnet.microsoft.com/en-us/download/dotnet-framework"));
        text.Line(".");

        text.Line("Microsoft launched VB.NET in 2002 as the successor to its original Visual Basic language.");
    }));
});

La classe TextContainer fournit des méthodes pour dessiner du texte, des liens et des numéros de page. Utilisez les méthodes Span et Line pour ajouter du texte à une ligne actuelle. La méthode Line complète en outre la ligne actuelle. Cet exemple utilise également la méthode Hyperlink qui ajoute un lien de ressource externe.

Voici un autre exemple montrant comment utiliser des numéros de page dynamiques dans un pied de page :

PdfDocumentBuilder.Create().Generate("footer.pdf", doc =>
{
    doc.Pages(p => p.Footer().AlignRight().Text(text =>
    {
        text.Style(t => t.Parent.FontColor(new PdfRgbColor(255, 0, 0)));

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

L'API de mise en page fournit un moyen de formater les numéros de page. Par exemple, vous pouvez dessiner des numéros de page hexadécimaux comme celui-ci :

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

L'exemple Ajouter un en-tête et un pied de page aux documents PDF dans un exemple C# et VB.NET montre comment formater les numéros de page en chiffres romains.

Vous constaterez peut-être que les exemples ci-dessus utilisent la méthode Style. Examinons plus en détail le concept de styles de texte.

Typographie

Les styles de texte vous permettent de personnaliser l'apparence du texte. La classe TextStyle fournit des méthodes pour modifier la taille de la 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 un nouveau style de texte. Vous pouvez appliquer un style de texte à différents niveaux de mise en page :

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

        page.Content()
            .TextStyle(TextStyle.Parent.FontColor(new PdfRgbColor(0, 0, 255)))
            .Text(t =>
            {
                t.Style(TextStyle.Parent.Underline());

                t.Span("Hello PDF").Style(TextStyle.Parent.DirectionRightToLeft());
            });
    });
});

La propriété TextStyle.Parent renvoie un style spécial avec toutes les propriétés de texte non définies. L'exemple précédent dessine "Hello PDF" en bleu, souligné, avec une taille de police de 30 points dans l'ordre inverse (de droite à gauche). Regardez l'exemple Personnaliser l'apparence du texte dans les documents PDF pour un autre exemple d'héritage de style de texte.

La classe TextStyle prend en charge tout personnaliser sauf une police associée. Utilisez les méthodes Document.TextStyleWithFont lorsque vous devez spécifier une police personnalisée pour votre style de texte. Cet exemple C# montre comment utiliser une police système :

PdfDocumentBuilder.Create().Generate("fonts.pdf", doc =>
{
    doc.Pages(page =>
    {
        TextStyle style = doc.TextStyleWithFont(SystemFont.Family("Arial").Bold());
        page.Content().Text("Bold text").Style(style);
    });
});

Le moteur de mise en page supprime par défaut les glyphes de police inutilisés. Pour cette raison, les documents générés peuvent avoir une petite taille, même pour les grandes polices. Vous pouvez également spécifier un chargeur de polices personnalisé, des polices de secours et un gestionnaire pour les glyphes manquants. Consultez l'exemple Utiliser différentes polices dans les documents PDF pour plus de détails.

L'API de mise en page fournit une collection de styles prédéfinis. Vous pouvez les utiliser ou les personnaliser via la Classe Typographie :

PdfDocumentBuilder.Create().Generate("typography.pdf", doc =>
{
    doc.Typography(t =>
    {
        var baseFont = new FileInfo("arial.ttf");
        t.Document = doc.TextStyleWithFont(baseFont);
        t.Header = t.Parent.FontSize(20).FontColor(new PdfGrayColor(20));
        t.Footer = t.Footnote;
    });

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

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

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

Avec la classe Typographie, vous n'avez pas besoin d'utiliser de variables pour conserver les références de style de texte. Vous enregistrez les styles nécessaires à l'aide des méthodes Document.Typography et les chargez plus tard à partir de l'objet Typography. Découvrez comment utiliser des styles prédéfinis et personnalisés dans l'exemple Typography.

Images

Tout comme le texte et les polices, les images constituent un autre élément fondamental des documents PDF. L'API de mise en page vous permet d'ajouter des images comme celle-ci :

PdfDocumentBuilder.Create().Generate("image.pdf", doc =>
{
    var imageFile = new FileInfo("image.jpg");
    Image image = doc.Image(imageFile);
    doc.Pages(page => page.Content().MaxWidth(200).Image(image));
});

Tableaux

L'API de mise en page vous permet de générer des tableaux. Cet exemple C# montre comment ajouter un tableau à un document PDF :

PdfDocumentBuilder.Create().Generate("table.pdf", doc =>
{
    doc.Pages(page =>
    {
        page.Content().Table(t =>
        {
            t.Columns(c =>
            {
                c.ConstantColumn(200);
                c.RelativeColumn(1);
            });

            t.Header(h =>
            {
                h.Cell().Text("Product");
                h.Cell().Text("Features");
            });

            t.Cell().Text("Docotic.Pdf");
            t.Cell().Text("Extract text, PDF to images, compress PDF");
            t.Cell().Text("Docotic.Pdf.Layout");
            t.Cell().Text("Create PDF");
        });
    });
});

Vous pouvez créer des tableaux de toute complexité. Cet exemple montre comment utiliser les bordures, les arrière-plans et les étendues des cellules.

Les documents PDF prennent en charge les liens internes qui vous permettent de générer des signets ou une table des matières. Cet exemple C# de base montre comment ajouter un lien vers une section de document à l'aide de l'API de mise en page :

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

            c.Item().PageBreak();

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

Vous pouvez également télécharger et essayer l'exemple Ajouter une table des matières aux documents PDF à partir de GitHub.

Dispositions complexes

Vous pouvez combiner différents composants de mise en page pour générer des documents PDF complexes. Téléchargez et essayez l'exemple Générer des documents PDF avec une mise en page complexe à partir de GitHub.

Il est possible d'étendre l'API de mise en page. Les méthodes LayoutContainer.Component et LayoutContainer.Container vous permettent de réutiliser des composants personnalisés. L'exemple Layout Components montre comment implémenter un composant personnalisé à l'aide de l'interface ILayoutComponent.

Conclusion

Bibliothèque Docotic.Pdf fournit différents moyens de créer des documents PDF en C# et VB.NET. Vous pouvez générer des documents PDF à partir de zéro avec ou sans utiliser le module complémentaire de mise en page. Ou vous pouvez créer un PDF à partir de HTML en utilisant le module complémentaire HTML vers PDF.

Contactez-nous si vous avez des questions sur la génération de PDF.