Merge PDF

Le Gestionnaire de PDF Documentize pour .NET est un outil polyvalent conçu pour fusionner plusieurs documents PDF en un seul fichier. Il simplifie la consolidation des fichiers PDF, garantissant que vos documents sont fusionnés efficacement et en maintenant la cohérence du contenu. Le plugin gère les ressources internes telles que les polices et les images pour optimiser le document fusionné.

Comment fusionner un PDF

Pour fusionner plusieurs documents PDF en un seul fichier, suivez ces étapes :

1. Créez une instance de MergeOptions pour configurer le processus de fusion.
2. Ajoutez les fichiers PDF d’entrée en utilisant la méthode AddInput.
3. Ajoutez le fichier PDF de sortie en utilisant la méthode AddOutput.
4. Exécutez la fusion en utilisant la méthode Merge de la classe PdfManager.

1// Créez un objet MergeOptions pour définir les instructions
2var options = new MergeOptions();
3// Ajoutez les chemins des fichiers d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file_1.pdf"));
5options.AddInput(new FileDataSource("path_to_your_pdf_file_2.pdf"));
6// Définissez le chemin du fichier de sortie
7options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
8// Effectuez le processus
9PdfManager.Merge(options);

Caractéristiques clés :

• Fusionner plusieurs PDF : Combinez facilement plusieurs fichiers PDF en un seul.
• Optimisation des ressources : Supprime les polices et images dupliquées lors de la fusion.
• Traitement par lots : Fusionnez de grands lots de documents PDF en une seule opération.

Split PDF

Le Gestionnaire de PDF Documentize pour .NET est un outil puissant qui simplifie le processus de division de grands documents PDF en fichiers plus petits et plus faciles à gérer. Que vous ayez besoin d’extraire des pages individuelles ou de diviser un document en sections spécifiques, ce plugin vous permet d’y arriver efficacement et avec un minimum d’effort.

Comment Diviser un PDF

Pour diviser un document PDF en pages individuelles, suivez ces étapes :

1. Créez une instance de SplitOptions pour configurer les options de division.
2. Ajoutez le fichier PDF d’entrée en utilisant la méthode AddInput.
3. Ajoutez des fichiers de sortie pour chaque page divisée en utilisant la méthode AddOutput.
4. Exécutez la méthode Split dans la classe PdfManager pour diviser le document.

1// Créer un objet SplitOptions pour définir les instructions
2var options = new SplitOptions();
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Définir les chemins des fichiers de sortie
6options.AddOutput(new FileDataSource("path_to_result_pdf_file_1.pdf"));
7options.AddOutput(new FileDataSource("path_to_result_pdf_file_2.pdf"));
8// Effectuer le processus
9PdfManager.Split(options);

Caractéristiques Clés :

• Diviser le PDF par Page : Décomposer un document PDF en pages individuelles.
• Options de Division Personnalisées : Configurer le processus de division en fonction de vos besoins.
• Sortie Organisée : Gérer facilement les fichiers de sortie pour chaque page ou section divisée.

Optimize PDF

Le Gestionnaire de PDF de Documentize pour .NET est un plugin complet qui améliore les documents PDF grâce à des techniques d’optimisation avancées. Il est conçu pour aider à réduire les tailles de fichiers, faire pivoter les pages, recadrer le contenu et redimensionner les documents. Ces opérations améliorent la qualité et la gestion des fichiers PDF, les rendant plus faciles à stocker, partager et visualiser.

Optimize PDF

Les étapes suivantes démontrent comment optimiser un document PDF en réduisant sa taille de fichier tout en maintenant sa qualité.

1. Créez un objet OptimizeOptions pour configurer les paramètres d’optimisation.
2. Ajoutez le(s) fichier(s) PDF d’entrée et définissez un emplacement de sortie pour le fichier optimisé.
3. Exécutez la méthode Optimize de PdfManager pour lancer l’optimisation.

1// Create OptimizeOptions object to set instructions
2var options = new OptimizeOptions();
3// Add input file path
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfManager.Optimize(options);

Rotate PDF

Utilisez la classe RotateOptions pour ajuster l’orientation des pages dans un fichier PDF.

1. Créez un objet RotateOptions et configurez l’angle de rotation.
2. Ajoutez le fichier PDF d’entrée et spécifiez l’emplacement du fichier de sortie.
3. Définissez l’angle de rotation (par exemple, 90 degrés) à l’aide de la méthode SetRotation.
4. Exécutez la méthode Rotate de PdfManager.

 1// Create RotateOptions object to set instructions
 2var options = new RotateOptions();
 3// Set new Rotation
 4options.Rotation = Rotation.On90;
 5// Add input file path
 6options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
 7// Set output file path
 8options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
 9// Perform the process
10PdfManager.Rotate(options);

Resize PDF

Pour redimensionner un document PDF, la classe ResizeOptions est utilisée pour spécifier la nouvelle taille de page du document.

1. Créez un objet ResizeOptions pour définir la taille de la page.
2. Ajoutez le fichier d’entrée et définissez l’emplacement de sortie souhaité.
3. Utilisez la méthode SetPageSize pour spécifier la nouvelle taille (par exemple, A4).
4. Exécutez la méthode Resize de PdfManager.

 1// Create ResizeOptions object to set instructions
 2var options = new ResizeOptions();
 3// Set new PageSize
 4options.PageSize = PageSize.A3;
 5// Add input file path
 6options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
 7// Set output file path
 8options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
 9// Perform the process
10PdfManager.Resize(options);

Compress PDF

Compressez le document PDF lorsque cela est possible en éliminant les ressources de page inutilisées, en fusionnant des actifs identiques et en supprimant des objets redondants.

1. Créez un objet CompressOptions pour configurer les paramètres d’optimisation.
2. Ajoutez le fichier d’entrée et spécifiez l’emplacement du fichier de sortie.
3. Utilisez la méthode SetCropBox pour définir la zone de recadrage.
4. Exécutez la méthode Compress de PdfManager.

1// Create CompressOptions object to set instructions
2var options = new CompressOptions();
3// Add input file path
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfManager.Compress(options);

Key Features:

• Optimisation : Réduisez la taille des fichiers PDF sans perdre en qualité.
• Rotation : Ajustez l’orientation des pages PDF.
• Redimensionnement : Redimensionnez les pages à des dimensions spécifiques (par exemple, A4, Lettre).
• Compression : Supprimez les ressources et objets de page inutilisés du document.

Add Table

Le Documentize PDF Manager for .NET est un plugin polyvalent conçu pour faciliter l’intégration de tables dans des documents PDF. Que vous organisiez des données, conceviez des formulaires ou amélioriez la lisibilité des documents, ce plugin simplifie le processus tout en maintenant la précision et l’efficacité. Son API intuitive prend en charge les flux de traitement de documents uniques et par lots, ce qui en fait un outil essentiel pour les développeurs travaillant avec des données structurées.

Créer un PDF avec des Tables

Suivez ces étapes pour créer des tables structurées dans un PDF en utilisant la classe TableOptions :

1. Configurez l’objet TableOptions pour définir la structure, le contenu et les fichiers d’entrée/sortie de la table.
2. Ajoutez des tables, des lignes et des cellules à votre PDF.
3. Finalisez le processus de génération de la table en utilisant la méthode AddTable.

Voici un exemple :

 1// Configurez les options de table
 2var options = new TableOptions();
 3options.InsertPageBefore(1)
 4   .AddTable()
 5        .AddRow()
 6            .AddCell().AddParagraph("Nom")
 7            .AddCell().AddParagraph("Âge")
 8        .AddRow()
 9            .AddCell().AddParagraph("Bob")
10            .AddCell().AddParagraph("12")
11        .AddRow()
12            .AddCell().AddParagraph("Sam")
13            .AddCell().AddParagraph("20")
14        .AddRow()
15            .AddCell().AddParagraph("Sandy")
16            .AddCell().AddParagraph("26")
17        .AddRow()
18            .AddCell().AddParagraph("Tom")
19            .AddCell().AddParagraph("12")
20        .AddRow()
21            .AddCell().AddParagraph("Jim")
22            .AddCell().AddParagraph("27");
23// Ajoutez le chemin du fichier d'entrée
24options.AddInput(new FileDataSource("path_to_input.pdf"));
25// Définissez le chemin du fichier de sortie
26options.AddOutput(new FileDataSource("path_to_output.pdf"));
27// Effectuez le processus
28PdfManager.AddTable(options);

Définir la page de la table

Suivez ces étapes pour créer une table dans un PDF après la page 2 : Voici un exemple :

 1var options = new TableOptions();
 2options.InsertPageBefore(2) // Ajoutez la table avant la page 2
 3   .AddTable()
 4        .AddRow()
 5            .AddCell().AddParagraph("Nom")
 6            .AddCell().AddParagraph("Âge")
 7// Ajoutez le chemin du fichier d'entrée
 8options.AddInput(new FileDataSource("path_to_input.pdf"));
 9// Définissez le chemin du fichier de sortie
10options.AddOutput(new FileDataSource("path_to_output.pdf"));
11// Effectuez le processus
12PdfManager.AddTable(options);

Fonctionnalités Clés :

• Création de Table Dynamique : Générez sans effort des tables structurées dans des documents PDF.
• Placement de Page : Insérez des tables à des emplacements spécifiques dans un PDF avec précision.
• Mise en Page Personnalisable : Ajustez la structure de la table, l’alignement des cellules et le style.

Add TOC

Le Documentize PDF Manager pour .NET est un plugin puissant conçu pour améliorer l’organisation et la navigation des documents PDF en générant dynamiquement une Table des Matières (TOC). Ce plugin simplifie le processus d’ajout de TOCs à vos PDFs, rendant les documents plus faciles à naviguer et à gérer.

Comment générer une TOC pour un PDF

Pour créer une Table des Matières dans un fichier PDF, suivez ces étapes :

1. Créez une instance de TocOptions pour configurer les paramètres de génération de la TOC.
2. Définissez un Titre en utilisant la propriété Title.
3. Concevez les En-têtes de la TOC en utilisant la méthode Headings.Add.
4. Ajoutez le fichier PDF d’entrée en utilisant la méthode AddInput.
5. Spécifiez le fichier PDF de sortie avec la TOC en utilisant la méthode AddOutput.
6. Appelez la méthode AddTableOfContents pour générer la TOC.

 1// Créez un objet TocOptions pour définir les instructions
 2var options = new TocOptions();
 3// Définissez le Titre
 4options.Title = "Ma Table des Matières";
 5// Concevez les En-têtes
 6options.Headings.Add(new TocHeading("Introduction", 2));
 7options.Headings.Add(new TocHeading("Chapitre I", 3));
 8options.Headings.Add(new TocHeading("Chapitre II", 4));
 9options.Headings.Add(new TocHeading("Chapitre III", 5));
10// Ajoutez le chemin du fichier d'entrée
11options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
12// Définissez le chemin du fichier de sortie
13options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
14// Effectuez le processus
15PdfManager.AddTableOfContents(options);

Générer des signets dans une TOC pour un PDF

Vous pouvez utiliser la propriété ‘GenerateBookmarks’ pour la génération de signets.

 1// Créez un objet TocOptions pour définir les instructions
 2var options = new TocOptions();
 3// Définissez le Titre
 4options.Title = "Ma Table des Matières";
 5// Générez des liens dans les signets
 6options.GenerateBookmarks = true;
 7// Concevez les En-têtes
 8options.Headings.Add(new TocHeading("Introduction", 2, false, 1));
 9options.Headings.Add(new TocHeading("Chapitre I", 3, true, 1));
10options.Headings.Add(new TocHeading("Chapitre II", 4, true, 1));
11options.Headings.Add(new TocHeading("Exemple A", 4, true, 2));
12options.Headings.Add(new TocHeading("Exemple B", 4, true, 2));
13options.Headings.Add(new TocHeading("Exemple C", 4, true, 2));
14options.Headings.Add(new TocHeading("Exemple D", 4, true, 2));
15options.Headings.Add(new TocHeading("Chapitre III", 5, true, 1));
16// Ajoutez le chemin du fichier d'entrée
17options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
18// Définissez le chemin du fichier de sortie
19options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
20// Effectuez le processus
21PdfManager.AddTableOfContents(options);

Comment obtenir le Résultat en tant que Flux

 1// Créez un objet TocOptions pour définir les instructions
 2var options = new TocOptions();
 3// Définissez le Titre
 4options.Title = "Ma Table des Matières";
 5// Concevez les En-têtes
 6options.Headings.Add(new TocHeading("Introduction", 2, false, 1));
 7// Ajoutez le chemin du fichier d'entrée
 8options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
 9// Définissez le flux de sortie 
10var outputStream = new MemoryStream();
11options.AddOutput(new StreamDataSource(outputStream));
12options.CloseOutputStreams = false;
13// Effectuez le processus
14PdfManager.AddTableOfContents(options);

Personnalisation de l’En-tête de la TOC

Vous pouvez personnaliser l’En-tête de la Table des Matières en modifiant la classe TocHeading. Par exemple, vous pouvez utiliser ‘GenerateNumbering’ ou le faire manuellement. La propriété ‘PageNumber’ est utilisée pour les liens vers les pages. Vous pouvez également utiliser la propriété Level.

 1var heading = new TocHeading();
 2heading.Text = "Intro";
 3heading.PageNumber = 5;
 4heading.GenerateNumbering = true;
 5heading.Level = 2;
 6
 7var tocOptions = new TocOptions();
 8options.Headings.Add(heading);
 9// Ajoutez les fichiers d'entrée et de sortie
10tocOptions.AddInput(new FileDataSource(@"C:\Samples\input.pdf"));
11tocOptions.AddOutput(new FileDataSource(@"C:\Samples\output_with_toc.pdf"));
12
13// Générez la TOC avec des options personnalisées
14PdfManager.AddTableOfContents(tocOptions);

Caractéristiques Clés:

• Génération de TOC Dynamique : Créez une TOC pour n’importe quel fichier PDF avec des entrées automatiquement générées en fonction des en-têtes ou des signets.
• Personnalisation : Contrôlez l’apparence et la structure de la TOC, y compris les styles, le formatage et les niveaux de profondeur.
• Flux de Travail Efficace : Minimisez le temps passé à créer manuellement des TOCs, en particulier pour des documents volumineux ou complexes.

Use ChatGPT

Le Documentize PDF Manager pour .NET est un outil puissant conçu pour intégrer l’API ChatGPT avec des applications PDF. Ce plugin permet aux développeurs de générer des réponses de chat basées sur des messages d’entrée et de sauvegarder la sortie au format PDF, ce qui le rend adapté à la création d’interfaces conversationnelles ou de rapports d’analyse directement dans les documents PDF.

Générer des Réponses de Chat

Pour générer des réponses de chat et les sauvegarder dans un fichier PDF en utilisant le plugin ChatGPT, suivez ces étapes :

1. Créez une instance de la classe ChatGptRequestOptions pour configurer les options de demande.
2. Ajoutez des fichiers PDF d’entrée et de sortie.
3. Définissez la clé API et spécifiez des paramètres tels que le nombre maximum de jetons et la requête pour le modèle ChatGPT.
4. Exécutez la méthode CreatePdfByChatGptRequestAsync pour générer la complétion de chat.

 1var options = new ChatGptRequestOptions();
 2// Définir le chemin du fichier de sortie
 3options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf")); 
 4options.ApiKey = "Votre clé API."; // Vous devez fournir la clé pour accéder à l'API.
 5options.MaxTokens = 1000; // Le nombre maximum de jetons à générer dans la complétion de chat.
 6
 7// Ajouter les messages de demande.
 8options.Messages.Add(new Message
 9{
10    Content = "Vous êtes un assistant utile.",
11    Role = Role.System
12});
13options.Messages.Add(new Message
14{
15    Content = "Quel est le plus grand diamètre de pizza jamais fabriqué ?",
16    Role = Role.User
17});
18
19// Traiter la demande.
20var result = await PdfManager.CreatePdfByChatGptRequestAsync(options);
21
22var fileResultPath = result.ResultCollection[0].Data;
23var chatCompletionObject = result.ResultCollection[1].Data as ChatCompletion; // L'objet de complétion de chat de l'API ChatGPT.

Ajout de Messages Système et Utilisateur

Pour créer une conversation plus interactive, vous pouvez ajouter à la fois des messages système et utilisateur. Ces messages aident à façonner le contexte de la conversation.

1. Ajoutez un message système qui définit le contexte pour ChatGPT.
2. Ajoutez un message utilisateur qui représente l’entrée de l’utilisateur pour la conversation.

 1var options = new ChatGptRequestOptions();
 2// Définir le chemin du fichier de sortie
 3options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
 4
 5// Ajouter la source de texte PDF.
 6// En cas de plusieurs sources, le texte de chaque document sera ajouté à la collection de messages de demande
 7// en tant que message séparé avec le rôle "utilisateur".
 8options.AddInput(new FileDataSource("TextSource.pdf"));
 9
10options.ApiKey = "Votre clé API."; // Vous devez fournir la clé pour accéder à l'API.
11options.MaxTokens = 1000; // Le nombre maximum de jetons à générer dans la complétion de chat.
12
13// Ajouter le message de demande.
14// Dans ce cas, le message système avec Content = "Vous êtes un assistant utile." est ajouté par défaut.
15// Le rôle du message de requête est "utilisateur" par défaut.
16options.Query = "Combien de lettres dans le texte fourni ?";
17
18// Traiter la demande.
19var result = await PdfManager.CreatePdfByChatGptRequestAsync(options);
20
21var fileResultPath = result.ResultCollection[0].Data;
22var chatCompletionObject = result.ResultCollection[1].Data as ChatCompletion; // L'objet de complétion de chat de l'API ChatGPT.

Fonctionnalités Clés:

• Complétions de Chat : Générer des réponses en utilisant l’API ChatGPT basée sur des entrées personnalisées.
• Messages Système & Utilisateur : Fournir à la fois le contexte système et l’entrée utilisateur pour créer des conversations dynamiques.
• Sortie PDF : Sauvegarder les complétions de chat générées dans un fichier PDF structuré pour une utilisation ultérieure.
• Traitement Asynchrone : Assurer des applications réactives en traitant les complétions de chat de manière asynchrone.