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.
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.
9.5.17573-dev 9.5.17573-dev 9.5.17573-dev14,726 réussis Téléchargements totaux de NuGet 4,765,230
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 les binaires de la bibliothèque. Obtenez la bibliothèque, les modules complémentaires et une clé de licence gratuite à durée limitée sur la page Télécharger la bibliothèque PDF C# .NET.
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 contenuHeader()
- un en-tête commun pour toutes les pagesContent()
- le contenu d'une page principaleFooter()
- un pied de page commun à toutes les pagesForeground()
- 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.
Liens internes
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.