HTML en PDF

Le Documentize PDF Converter for .NET offre des capacités robustes pour convertir des documents du format HTML vers PDF, idéal pour les applications web, l’archivage et la génération de rapports. Avec de multiples options de gestion des ressources et des mises en page, le convertisseur s’adapte à diverses exigences de projet.

Conversion de HTML en PDF

Transformez le contenu HTML en PDF de haute qualité, parfait pour générer des rapports imprimables, archiver du contenu web ou créer des formats de documents partageables.
Pour convertir un document HTML en PDF, suivez ces étapes :

1. Configurer les options : utilisez HtmlToPdfOptions pour définir les paramètres de mise en page et de média.
2. Spécifier les chemins : indiquez les chemins du fichier HTML d’entrée et du fichier PDF de sortie.
3. Exécuter la conversion : appelez la méthode Convert de PdfConverter pour réaliser la conversion.

Exemple : Conversion de HTML en PDF

1  
2// Create HtmlToPdfOptions  
3var options = new HtmlToPdfOptions();  
4// Add input file path  
5options.AddInput(new FileData("path_to_input.html"));  
6// Set output file path  
7options.AddOutput(new FileData("path_to_output.pdf"));  
8//Perform the process  
9PdfConverter.Convert(options);  

Options supplémentaires pour la conversion HTML en PDF

• Type de média :

  • HtmlMediaType.Print : idéal pour générer des PDF adaptés à l’impression.
  • HtmlMediaType.Screen : à utiliser lors de la conversion de contenu destiné à une visualisation numérique.

• Ajustements de mise en page :

  • PageLayoutOption : ajuste la façon dont le contenu HTML s’adapte à la mise en page du PDF, comme ScaleToPageWidth pour garantir que le contenu s’échelle à la largeur du PDF.
  • IsRenderToSinglePage : permet de rendre l’ensemble du contenu HTML sur une seule page PDF si nécessaire pour des présentations concises.

Ce convertisseur est polyvalent pour de nombreuses applications, de la génération de rapports PDF à partir de contenu web à la conversion d’archives de documents PDF pour une accessibilité en ligne. Pour des configurations plus avancées, consultez la documentation complète de Documentize.

PDF en DOC

Le Documentize PDF Converter for .NET est un outil puissant conçu pour convertir des documents PDF au format DOC. Ce composant transforme de manière fluide les pages PDF en documents Microsoft Word modifiables, facilitant la réutilisation, la modification et le partage du contenu sur plusieurs plateformes.

Comment convertir un PDF en DOC

Pour convertir un document PDF au format DOC, suivez ces étapes :

1. Créez une instance de PdfToDocOptions pour configurer le processus de conversion.
2. Ajoutez le fichier PDF d’entrée à l’aide de la méthode AddInput.
3. Ajoutez le chemin du fichier de sortie pour le fichier résultant à l’aide de la méthode AddOutput.
4. Exécutez la méthode Convert pour lancer la conversion.

1// Create PdfToDocOptions object to set instructions
2var options = new PdfToDocOptions();
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_file.doc"));
7// Perform the process
8PdfConverter.Convert(options);

Conversion PDF en DOC avec des options personnalisées

Le plugin PDF to DOC Converter propose plusieurs options pour personnaliser votre processus de conversion. Vous pouvez choisir parmi différents modes afin de contrôler la façon dont la mise en page et la structure du PDF sont gérées pendant la conversion.

 1// Create PdfToDocOptions object to set instructions
 2var options = new PdfToDocOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Set output file path
 6options.AddOutput(new FileData("path_to_result_file.doc"));
 7// Set Mode
 8options.Mode = DocConversionMode.Flow;
 9// Perform the process
10PdfConverter.Convert(options);

Principales caractéristiques :

• Conversion DOC : Convertissez les documents PDF en formats Microsoft Word modifiables (DOC).
• Maintien de la mise en forme : Conservez la disposition, le texte et le formatage d’origine pendant le processus de conversion.

PDF en HTML

Le Documentize PDF Converter for .NET offre des capacités robustes pour convertir des documents PDF au format HTML, idéal pour les applications Web, l’archivage et la génération de rapports. Avec de multiples options de gestion des ressources et de la mise en page, le convertisseur s’adapte à diverses exigences de projet.

Conversion de PDF en HTML

Convertissez des fichiers PDF en HTML pour rendre les documents accessibles en affichage Web ou les intégrer dans des applications où le format HTML est préféré.

1. Configurer les options : Utilisez PdfToHtmlOptions pour personnaliser la sortie, en choisissant des ressources intégrées ou externes.
2. Définir les chemins d’entrée et de sortie : Indiquez les chemins de votre PDF source et du fichier HTML destination.
3. Exécuter la conversion : Appelez la méthode Convert de PdfConverter pour convertir le fichier.

Exemple : Convertir un PDF en HTML avec des ressources intégrées

1// Create PdfToHtmlOptions object to set output data type as file with embedded resources
2var options = new PdfToHtmlOptions(PdfToHtmlOptions.SaveDataType.FileWithEmbeddedResources);
3// Add input file path
4options.AddInput(new FileData("path_to_input.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_output.html"));
7//Perform the process
8PdfConverter.Convert(options);

Options disponibles pour la conversion PDF vers HTML

• SaveDataType :
  • FileWithEmbeddedResources : Génère un fichier HTML unique avec toutes les ressources intégrées.
  • FileWithExternalResources : Enregistre les ressources séparément, idéal pour les fichiers HTML volumineux.

PDF en JPEG

Le Documentize PDF Converter for .NET est un outil puissant qui simplifie la conversion des documents PDF en images JPEG de haute qualité. Ce composant est conçu pour rendre votre contenu plus accessible sur toutes les plateformes en transformant les pages PDF en formats d’image largement utilisés.

Comment convertir des pages PDF en JPEG

Pour convertir un document PDF en images JPEG, suivez ces étapes :

1. Créez une instance de PdfToJpegOptions pour configurer le processus de conversion.
2. Ajoutez le fichier PDF d’entrée en utilisant la méthode AddInput.
3. Définissez le chemin du répertoire de sortie pour les images JPEG en utilisant la méthode AddOutput.
4. Exécutez la méthode Convert pour convertir les pages PDF en images JPEG.

1// Create PdfToJpegOptions object to set instructions
2var options = new PdfToJpegOptions();
3// Add input File path
4options.AddInput(new FileData("path_to_input.pdf"));
5// Set output Directory path
6options.AddOutput(new DirectoryData("path_to_output_directory"));
7// Perform the process
8PdfConverter.Convert(options);

Personnaliser la conversion PDF en JPEG

Vous pouvez personnaliser le processus de conversion en ajustant la résolution, en sélectionnant des plages de pages ou en définissant la qualité de l’image. Voici comment convertir la première page d’un PDF à 200 DPI :

 1// Create PdfToJpegOptions object to set instructions
 2var options = new PdfToJpegOptions();
 3// Process only the first page
 4options.PageList = [1];
 5// Set output resolution to 200 DPI
 6options.OutputResolution = 200;
 7// Set output quality to 50
 8options.Quality = 50;
 9// Add input File path
10options.AddInput(new FileData("path_to_input.pdf"));
11// Set output Directory path
12options.AddOutput(new DirectoryData("path_to_output_directory"));
13// Perform the process
14PdfConverter.Convert(options);

Comment obtenir les résultats sans répertoire, ou sous forme de flux

La méthode Convert renvoie un objet ResultContainer qui contient les informations sur les résultats de la conversion. Vous pouvez obtenir des flux des fichiers JPEG convertis comme indiqué ci-dessous :

 1// Create PdfToJpegOptions object to set instructions
 2var options = new PdfToJpegOptions();
 3// Add input File path
 4options.AddInput(new FileData("path_to_input.pdf"));
 5// Perform the process
 6var results = PdfConverter.Convert(options);
 7// Get stream results
 8foreach (var result in results.ResultCollection)
 9{
10    var streamResultPage1 = result.ToStream();
11}

Principales fonctionnalités :

• Convertir PDF en JPEG : Convertissez sans effort des documents PDF complets ou des pages spécifiques en images JPEG.
• Résolution personnalisée : Ajustez la résolution (par exemple, 300 dpi) pour des sorties de haute qualité.
• Ensemble de pages : Sélectionnez des pages spécifiques pour la conversion.
• Conversion rapide : Processus rapide et efficace avec un effort minimal.

PDF vers PDF/A

Le Documentize PDF Converter for .NET est un outil puissant conçu pour convertir des documents PDF au format PDF/A, garantissant que votre contenu reste conforme aux normes d’archivage à long terme. Ce composant prend également en charge la validation des documents PDF existants pour la conformité PDF/A, offrant à la fois des fonctionnalités de conversion et de validation dans une solution unique.

Comment convertir un PDF en PDF/A

Pour convertir un document PDF au format PDF/A, suivez ces étapes :

1. Créez une instance de PdfToPdfAOptions pour configurer la conversion.
2. Spécifiez la version PDF/A souhaitée (par ex., PDF/A-3B).
3. Ajoutez le fichier PDF d’entrée à l’aide de la méthode AddInput.
4. Ajoutez le fichier de sortie pour le PDF/A résultant à l’aide de la méthode AddOutput.
5. Appelez la méthode Convert pour exécuter la conversion.

 1// Créez la classe d'options pour configurer le processus de conversion
 2var options = new PdfToPdfAOptions
 3{
 4    PdfAVersion = PdfAStandardVersion.PDF_A_3B
 5};
 6
 7// Ajoutez le fichier source
 8options.AddInput(new FileData("path_to_your_pdf_file.pdf")); // remplacez par le chemin réel de votre fichier
 9
10// Ajoutez le chemin où enregistrer le fichier converti
11options.AddOutput(new FileData("path_to_the_converted_file.pdf"));
12
13// Exécutez la conversion
14PdfConverter.Convert(options);

Validation de la conformité PDF/A

Vous pouvez valider des fichiers PDF existants pour la conformité PDF/A à l’aide de la classe PdfAValidateOptions.

 1// Créez la classe d'options pour configurer le processus de validation
 2var options = new PdfAValidateOptions
 3{
 4    PdfAVersion = PdfAStandardVersion.PDF_A_1A
 5};
 6
 7// Ajoutez un ou plusieurs fichiers à valider
 8options.AddInput(new FileData("path_to_your_first_pdf_file.pdf")); // remplacez par le chemin réel de votre fichier
 9options.AddInput(new FileData("path_to_your_second_pdf_file.pdf"));
10// ajoutez d'autres fichiers si nécessaire
11
12// Exécutez la validation et récupérez les résultats
13var resultContainer = PdfConverter.Validate(options);
14
15// Consultez la propriété ResultCollection de resultContainer pour les résultats de validation de chaque fichier :
16foreach (var result in resultContainer.ResultCollection)
17{
18    var validationResult = (PdfAValidationResult) result.Data;
19    var isValid = validationResult.IsValid; // Résultat de la validation pour le document
20}

Fonctionnalités clés :

• Conversion en PDF/A : Transformez facilement les fichiers PDF en format PDF/A (tel que PDF/A-1a, PDF/A-2b, PDF/A-3b) pour garantir la conformité aux normes d’archivage.
• Validation de conformité PDF/A : Vérifiez les documents PDF existants pour vous assurer qu’ils respectent les normes PDF/A et identifiez les éventuels problèmes.
• Flux de travail efficace : Réduisez le temps et les efforts grâce à des processus de conversion rapides et fiables.

PDF en PNG

Le Documentize PDF Converter for .NET est un outil avancé qui vous permet de convertir des documents PDF en images PNG de haute qualité. Ce composant est conçu pour rendre votre contenu plus polyvalent, accessible et plus facile à partager en transformant les pages PDF en formats d’image largement supportés.

Comment convertir un PDF en PNG

Pour convertir un document PDF en images PNG, suivez ces étapes :

1. Créez une instance de PdfToPngOptions pour configurer le processus de conversion.
2. Ajoutez le fichier PDF d’entrée à l’aide de la méthode AddInput.
3. Définissez le chemin du répertoire de sortie pour les images PNG avec la méthode AddOutput.
4. Exécutez la méthode Convert pour convertir les pages PDF en images PNG.

1// Create PdfToPngOptions object to set instructions
2var options = new PdfToPngOptions();
3// Add input File path
4options.AddInput(new FileData("path_to_input.pdf"));
5// Set output Directory path
6options.AddOutput(new DirectoryData("path_to_output_directory"));
7// Perform the process
8PdfConverter.Convert(options);

Personnalisation de la conversion PDF en PNG

Vous pouvez personnaliser la conversion en ajustant la résolution et en sélectionnant des pages spécifiques. Par exemple, pour ne convertir que la première page d’un PDF à 200 DPI :

 1// Create PdfToPngOptions object to set instructions
 2var options = new PdfToPngOptions()
 3// Process only the first page
 4options.PageList = [1];
 5// Set output resolution to 200 DPI
 6options.OutputResolution = 200;
 7// Add input File path
 8options.AddInput(new FileData("path_to_input.pdf"));
 9// Set output Directory path
10options.AddOutput(new DirectoryData("path_to_output_directory"));
11// Perform the process
12PdfConverter.Convert(options);

Gestion des résultats de conversion

La méthode Convert renvoie un objet ResultContainer qui contient des informations sur les résultats de la conversion. Vous pouvez obtenir les flux des fichiers PNG convertis comme indiqué ci‑dessous :

 1// Create PdfToJpegOptions object to set instructions
 2var options = new PdfToPngOptions();
 3// Add input File path
 4options.AddInput(new FileData("path_to_input.pdf"));
 5// Perform the process
 6var results = PdfConverter.Convert(options);
 7// Get stream results
 8foreach (var result in results.ResultCollection)
 9{
10    var streamResultPage1 = result.ToStream();
11}

Principales fonctionnalités :

• Convertir PDF en PNG : Convertissez rapidement et efficacement des documents PDF entiers ou des pages spécifiques en images PNG.
• Résolution personnalisable : Définissez le DPI souhaité (par ex., 300 DPI) pour une sortie d’image de haute qualité.
• Ensemble de pages : Sélectionnez des pages spécifiques à convertir.
• Gestion facile de la sortie : Spécifiez les répertoires de destination pour chaque fichier PNG converti.
• Conversion rapide : Rapide, efficace, et nécessite peu d’effort pour la configuration.

PDF en TIFF

Le Documentize PDF Converter for .NET est un outil puissant conçu pour convertir des documents PDF en images TIFF de haute qualité. Ce composant garantit que votre contenu est accessible sur diverses plates‑formes tout en conservant une excellente fidélité et polyvalence. Vous pouvez personnaliser le processus de conversion en ajustant la résolution, en activant la sortie multi‑pages ou en sélectionnant des pages.

Comment convertir un PDF en TIFF

Pour convertir un document PDF en images TIFF, suivez ces étapes :

1. Créez une instance de PdfToTiffOptions pour configurer le processus de conversion.
2. Ajoutez le fichier PDF d’entrée à l’aide de la méthode AddInput.
3. Spécifiez le chemin du fichier de sortie pour les images TIFF avec la méthode AddOutput.
4. Exécutez la méthode Convert pour convertir les pages du PDF en images TIFF.

1// Create PdfToTiffOptions object to set instructions
2var options = new PdfToTiffOptions();
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output Directory path
6options.AddOutput(new DirectoryData("path_to_output_directory"));
7// Perform the process
8PdfConverter.Convert(options);

Personnalisation des pages et du DPI lors de la conversion PDF en TIFF

Voici comment convertir 2 pages d’un PDF à 400 DPI dans un fichier TIFF :

 1// Create PdfToTiffOptions object to set instructions
 2var options = new PdfToTiffOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Set output Directory path
 6options.AddOutput(new DirectoryData("path_to_output_directory"));
 7// Set Pages
 8options.PageList = [1, 3];
 9// Set result image Resolution
10options.OutputResolution = 400;
11// Perform the process
12PdfConverter.Convert(options);

Création de TIFF multi‑pages

Le plug‑in prend en charge la génération de TIFF multi‑pages, vous permettant de combiner plusieurs pages PDF en un seul fichier TIFF pour un archivage ou une impression efficaces.

 1// Create PdfToTiffOptions object to set instructions
 2var options = new PdfToTiffOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Set output Directory path
 6options.AddOutput(new DirectoryData("path_to_output_directory"));
 7// Enable Multi-Page TIFF output
 8options.MultiPage = true;
 9// Perform the process
10PdfConverter.Convert(options);

Personnalisation des pages, de la compression et de la profondeur de couleur

Voici comment convertir 2 pages d’un PDF à 400 DPI dans un fichier TIFF en définissant la compression et la profondeur de couleur :

 1// Create PdfToTiffOptions object to set instructions
 2var options = new PdfToTiffOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Set output Directory path
 6options.AddOutput(new DirectoryData("path_to_output_directory"));
 7// Set Compression and ColorDepth
 8options.Compression = TiffCompression.RLE;
 9options.ColorDepth = TiffColorDepth.Format24bpp;
10// Perform the process
11PdfConverter.Convert(options);

Gestion des résultats de conversion

La méthode Convert renvoie un objet ResultContainer qui fournit des détails sur les résultats de la conversion. Vous pouvez obtenir des flux des fichiers TIFF convertis comme indiqué ci‑dessous :

 1// Create PdfToTiffOptions object to set instructions
 2var options = new PdfToTiffOptions();
 3// Add input File path
 4options.AddInput(new FileData("path_to_input.pdf"));
 5// Perform the process
 6var results = PdfConverter.Convert(options);
 7// Get stream results
 8foreach (var result in results.ResultCollection)
 9{
10    var streamResultPage1 = result.ToStream();
11}

Principales fonctionnalités :

• Convertir PDF en TIFF : Convertissez facilement des documents PDF entiers ou des pages spécifiques en images TIFF.
• Résolution personnalisée : Ajustez la résolution (par ex. 300 dpi) pour des sorties de qualité supérieure.
• TIFF multi‑pages : Regroupez plusieurs pages PDF en un seul fichier TIFF multi‑pages.
• Sélection de pages : Choisissez les pages à convertir.
• Conversion rapide : Processus rapide et efficace avec un minimum d’effort.

PDF en XLS

Le Documentize PDF Converter for .NET est un outil polyvalent et puissant pour convertir des documents PDF en feuilles de calcul Excel (XLSX/XLS/CSV/XLSM/ODS). En tirant parti de ce composant, les développeurs peuvent transformer sans effort les données PDF statiques en feuilles de calcul dynamiques et modifiables, simplifiant la manipulation, l’analyse et le partage des données.

Comment convertir un PDF en Excel

Pour convertir un document PDF en fichier Excel (XLSX), suivez ces étapes :

1. Configurez les paramètres de conversion à l’aide de la classe PdfToXlsOptions.
2. Ajoutez les fichiers PDF d’entrée avec la méthode AddInput.
3. Spécifiez le chemin du fichier de sortie avec la méthode AddOutput.
4. Exécutez la méthode Convert pour lancer la conversion.

1// Create PdfToXlsOptions object to set instructions
2var options = new PdfToXlsOptions();
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_xlsx_file.xlsx"));
7// Perform the process
8PdfConverter.Convert(options);

Personnalisation de la conversion PDF vers Excel

La classe PdfToXlsOptions vous permet de personnaliser le processus de conversion. Par exemple, pour convertir le PDF en fichier XLS et activer des options de formatage avancées :

 1// Create PdfToXlsOptions object to set instructions
 2var options = new PdfToXlsOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Specify XLS format
 6options.Format = PdfToXlsOptions.ExcelFormat.XMLSpreadSheet2003;
 7options.InsertBlankColumnAtFirst = true;
 8options.MinimizeTheNumberOfWorksheets = true;
 9// Set output file path
10options.AddOutput(new FileData("path_to_result_xlsx_file.xls"));
11// Perform the process
12PdfConverter.Convert(options);

Formats de sortie pris en charge

L’énumération PdfToXlsOptions.ExcelFormat propose plusieurs formats de sortie :

• XLSX : format de fichier Office Open XML (.xlsx) (par défaut).
• XLSM : format Excel avec macros.
• CSV : valeurs séparées par des virgules.
• ODS : feuille de calcul Open Document.
• XMLSpreadSheet2003 : format XML Excel 2003 (.xls).

Principales fonctionnalités :

• Options de conversion flexibles : convertissez des fichiers PDF en XLSX, XLS, CSV ou autres formats.
• Préservation du contenu : conservez la structure, la mise en page et le formatage d’origine.
• Formatage avancé : insérez des colonnes vides ou réduisez le nombre de feuilles de calcul.

Extraire du texte

Le Documentize PDF Extractor for .NET simplifie l’extraction de texte à partir de documents PDF. Que vous ayez besoin de texte pur, brut ou simple, ce plugin vous permet d’extraire le texte efficacement tout en préservant le formatage ou en l’ignorant selon vos besoins.

Comment extraire du texte d’un fichier PDF

Pour extraire le texte d’un fichier PDF, suivez ces étapes :

1. Créez une instance de ExtractTextOptions pour configurer le chemin du fichier d’entrée.
2. Exécutez la méthode Extract pour extraire le texte.

1// Create ExtractTextOptions object to set input file path
2var options = new ExtractTextOptions("path_to_your_pdf_file.pdf");
3// Perform the process and get the extracted text
4var textExtracted = PdfExtractor.Extract(options);

Comment extraire du texte d’un flux PDF

Pour extraire le texte d’un flux PDF, suivez ces étapes :

1. Créez une instance de ExtractTextOptions pour configurer le flux d’entrée.
2. Exécutez la méthode Extract pour extraire le texte.

1// Create ExtractTextOptions object to set input stream
2var stream = File.OpenRead("path_to_your_pdf_file.pdf");
3var options = new ExtractTextOptions(stream);
4// Perform the process and get the extracted text
5var textExtracted = PdfExtractor.Extract(options);

Modes d’extraction de texte

Le ExtractTextOptions offre trois modes d’extraction, offrant une flexibilité selon vos besoins.

1. Mode Pur : préserve le formatage original, y compris les espaces et l’alignement.
2. Mode Brut : extrait le texte sans formatage, utile pour le traitement de données brutes.
3. Mode Aplat : représente le contenu PDF avec des fragments de texte positionnés selon leurs coordonnées.

1// Create ExtractTextOptions object to set input file path and TextFormattingMode
2var options = new ExtractTextOptions("path_to_your_pdf_file.pdf", TextFormattingMode.Pure);
3// Perform the process and get the extracted text
4var textExtracted = PdfExtractor.Extract(options);

Comment extraire du texte d’un fichier PDF de la manière la plus concise possible

1// Perform the process and get the extracted text
2var textExtracted = PdfExtractor.Extract(new ExtractTextOptions("path_to_your_pdf_file.pdf", TextFormattingMode.Pure));

Principales fonctionnalités :

• Mode Pur : extrait le texte tout en préservant son formatage d’origine.
• Mode Brut : extrait le texte sans aucun formatage.
• Mode Aplat : extrait le texte sans caractères spéciaux ni mise en forme.

Extraire des images

Le plugin Documentize PDF Extractor for .NET vous permet d’extraire facilement des images de documents PDF. Il analyse vos fichiers PDF, identifie les images incorporées et les extrait tout en conservant leur qualité et leur format d’origine. Cet outil améliore l’accessibilité du contenu visuel et simplifie le processus de récupération des images à partir des PDF.

Comment extraire des images d’un PDF

Pour extraire des images d’un fichier PDF, suivez ces étapes :

1. Créez une instance de la classe ExtractImagesOptions.
2. Ajoutez le chemin du fichier d’entrée aux options à l’aide de la méthode AddInput.
3. Définissez le chemin du répertoire de sortie pour les images avec la méthode AddOutput.
4. Lancez le processus d’extraction d’images avec le plugin.
5. Récupérez les images extraites depuis le conteneur de résultats.

 1// Create ExtractImagesOptions to set instructions
 2var options = new ExtractImagesOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Set output Directory path
 6options.AddOutput(new DirectoryData("path_to_results_directory"));
 7// Perform the process
 8var results = PdfExtractor.Extract(options);
 9// Get path to image result
10var imageExtracted = results.ResultCollection[0].ToFile();

Extraction d’images d’un fichier PDF vers des flux sans dossier

Le plugin PdfExtractor prend en charge la sauvegarde vers des flux, ce qui vous permet d’extraire des images de fichiers PDF directement dans des flux sans utiliser de dossiers temporaires.

 1// Create ExtractImagesOptions to set instructions
 2var options = new ExtractImagesOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Not set output - it will write results to streams
 6// Perform the process
 7var results = PdfExtractor.Extract(options);
 8// Get Stream
 9var ms = results.ResultCollection[0].ToStream();
10// Copy data to file for demo
11ms.Seek(0, SeekOrigin.Begin);
12using (var fs = File.Create("test_file.png"))
13{
14    ms.CopyTo(fs);
15}

Fonctionnalités clés :

• Extraction d’images incorporées : Identifie et extrait les images des documents PDF.
• Préservation de la qualité des images : Garantit que les images extraites conservent leur qualité d’origine.
• Sortie flexible : Enregistrez les images extraites dans le format ou l’emplacement de votre choix.

Extraire les propriétés / métadonnées

Le Documentize PDF Extractor for .NET simplifie l’extraction des métadonnées des documents PDF. Propriétés disponibles qui peuvent vous intéresser : FileName, Title, Author, Subject, Keywords, Created, Modified, Application, PDF Producer, Number of Pages.

Comment extraire les métadonnées d’un fichier PDF

L’exemple montre comment extraire les propriétés (Title, Author, Subject, Keywords, Number of Pages) d’un fichier PDF.
Pour extraire les métadonnées d’un document PDF, suivez ces étapes :

1. Créez une instance de ExtractPropertiesOptions pour configurer les options d’extraction et le fichier PDF d’entrée.
2. Exécutez la méthode Extract de PdfExtractor pour extraire les métadonnées.
3. Accédez aux propriétés extraites à l’aide de PdfProperties.

 1// Create ExtractPropertiesOptions object to set input file
 2var options = new ExtractPropertiesOptions("path_to_your_pdf_file.pdf");
 3// Perform the process and get Properties
 4var pdfProperties = PdfExtractor.Extract(options);
 5var filename = pdfProperties.FileName;
 6var title = pdfProperties.Title;
 7var author = pdfProperties.Author;
 8var subject = pdfProperties.Subject;
 9var keywords = pdfProperties.Keywords;
10var created = pdfProperties.Created;
11var modified = pdfProperties.Modified;
12var application = pdfProperties.Application;
13var pdfProducer = pdfProperties.PdfProducer;
14var numberOfPages = pdfProperties.NumberOfPages;

Comment extraire les métadonnées d’un flux PDF

Vous pouvez ouvrir le flux à votre convenance.

 1// Create ExtractPropertiesOptions object to set input stream
 2var stream = File.OpenRead("path_to_your_pdf_file.pdf");
 3var options = new ExtractPropertiesOptions(stream);
 4// Perform the process and get Properties
 5var pdfProperties = PdfExtractor.Extract(options);
 6var title = pdfProperties.Title;
 7var author = pdfProperties.Author;
 8var subject = pdfProperties.Subject;
 9var keywords = pdfProperties.Keywords;
10var created = pdfProperties.Created;
11var modified = pdfProperties.Modified;
12var application = pdfProperties.Application;
13var pdfProducer = pdfProperties.PdfProducer;
14var numberOfPages = pdfProperties.NumberOfPages;

Comment extraire les métadonnées d’un fichier PDF de la manière la plus concise

1// Perform the process and get Properties
2var pdfProperties = PdfExtractor.Extract(new ExtractPropertiesOptions("path_to_your_pdf_file.pdf"));

Principales fonctionnalités :

• Métadonnées disponibles : FileName, Title, Author, Subject, Keywords, Created, Modified, Application, PDF Producer, Number of Pages.

Exporter les données de formulaire

Le plugin Documentize PDF Extractor for .NET offre une manière fluide d’extraire et d’exporter les données des formulaires PDF (AcroForms) vers d’autres formats comme le CSV. Cet outil dynamique simplifie le processus de récupération des valeurs des champs de formulaire, permettant une gestion, un transfert et une analyse faciles des données.

Comment exporter les données d’un formulaire PDF vers CSV

Pour exporter les données d’un formulaire PDF vers CSV, suivez ces étapes :

1. Créez une instance de la classe ExtractImagesOptions.
2. Définissez les options d’exportation à l’aide de la classe FormExporterValuesToCsvOptions.
3. Ajoutez les fichiers PDF d’entrée et spécifiez le fichier CSV de sortie.
4. Exécutez la méthode Extract pour réaliser l’exportation.

1// Create ExtractFormDataToDsvOptions object to set instructions
2var options = new ExtractFormDataToDsvOptions(',', true);
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_csv_file.csv"));
7// Perform the process
8PdfExtractor.Extract(options);

Comment exporter les données d’un formulaire PDF vers TSV

Utilisez la tabulation comme délimiteur.

 1// Create ExtractFormDataToDsvOptions object to set instructions
 2var options = new ExtractFormDataToDsvOptions();
 3//Set Delimiter
 4options.Delimiter = '\t';
 5//Add Field Names to result
 6options.AddFieldName = true;
 7// Add input file path
 8options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 9// Set output file path
10options.AddOutput(new FileData("path_to_result_csv_file.tsv"));
11// Perform the process
12PdfExtractor.Extract(options);

Principales fonctionnalités :

• Export Form Data : Extraire les données des formulaires PDF (AcroForms) vers CSV ou d’autres formats.
• Data Filtering : Utiliser des prédicats pour filtrer des champs de formulaire spécifiques à exporter selon des critères comme le type de champ ou le numéro de page.
• Flexible Output : Enregistrer les données exportées pour les analyser ou les transférer vers des feuilles de calcul, des bases de données ou d’autres formats de documents.

Fusionner PDF

The Documentize PDF Manager for .NET is a versatile tool designed to merge multiple PDF documents into a single file. It simplifies the consolidation of PDF files, ensuring your documents are merged efficiently and maintaining consistency across content. The component handles internal resources such as fonts and images to optimize the merged document.

How to Merge PDF

To merge multiple PDF documents into a single file, follow these steps:

1. Create an instance of MergeOptions to configure the merging process.
2. Add input PDF files using the AddInput method.
3. Add output PDF file using AddOutput method.
4. Execute the merge using the Merge method of PdfManager class.

1// Create MergeOptions object to set instructions
2var options = new MergeOptions();
3// Add input file paths
4options.AddInput(new FileData("path_to_your_pdf_file_1.pdf"));
5options.AddInput(new FileData("path_to_your_pdf_file_2.pdf"));
6// Set output file path
7options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
8// Perform the process
9PdfManager.Merge(options);

Key Features:

• Merge Multiple PDFs: Easily combine multiple PDF files into one.
• Resource Optimization: Removes duplicate fonts and images during merging.
• Batch Processing: Merge large batches of PDF documents in one go.

Diviser le PDF

Le Documentize PDF Manager pour .NET est un outil puissant qui simplifie le processus de division de gros 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 composant vous permet de le faire 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 à l’aide de la méthode AddInput.
3. Ajoutez les fichiers de sortie pour chaque page découpée à l’aide de la méthode AddOutput.
4. Exécutez la méthode Split de la classe PdfManager pour diviser le document.

1// Create SplitOptions object to set instructions
2var options = new SplitOptions();
3// Add input file path
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Set output file paths
6options.AddOutput(new FileData("path_to_result_pdf_file_1.pdf"));
7options.AddOutput(new FileData("path_to_result_pdf_file_2.pdf"));
8// Perform the process
9PdfManager.Split(options);

Principales fonctionnalités :

• Diviser le PDF par page : découpez un document PDF en pages individuelles.
• Options de division personnalisées : configurez le processus de découpage selon vos besoins.
• Sortie organisée : gérez facilement les fichiers de sortie pour chaque page ou section découpée.

Compresser PDF

Le PDF Manager est un outil complet qui améliore les documents PDF grâce à des techniques d’optimisation avancées. Ces opérations Compresser PDF les documents, les rendant plus faciles à stocker, partager et visualiser.

Compresser PDF

Compressez le document PDF lorsque cela est possible en éliminant les ressources de page inutilisées, en fusionnant les actifs identiques et en supprimant les 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 rognage.
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 FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfManager.Compress(options);

Fonctionnalités clés :

• Compression : Supprime les ressources de page et les objets inutilisés du document.

Faire pivoter les pages du PDF

Vous pouvez faire pivoter les pages de vos documents PDF en utilisant la classe PDF Manager. Après avoir créé un RotateOptions, vous pouvez définir l’angle souhaité pour la page et lancer le processus. Le PDF résultant reflétera les nouvelles dimensions, garantissant qu’il répond à des exigences spécifiques.

Faire pivoter le PDF

Utilisez la classe RotateOptions pour ajuster l’orientation des pages d’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 ex., 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 FileData("path_to_your_pdf_file.pdf"));
 7// Set output file path
 8options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 9// Perform the process
10PdfManager.Rotate(options);

Fonctionnalités clés :

• Rotation : Ajustez l’orientation des pages PDF.

Optimiser le PDF

Le PDF Manager est un outil complet qui améliore les documents PDF grâce à des techniques d’optimisation avancées. Il est conçu pour aider à réduire la taille des fichiers, faire pivoter les pages, recadrer le contenu et redimensionner les documents. Ces opérations améliorent la qualité et la maniabilité des fichiers PDF, les rendant plus faciles à stocker, partager et visualiser. L’optimisation, ou linéarisation pour le Web, désigne le processus qui rend un fichier PDF adapté à la navigation en ligne via un navigateur web.

Optimiser le PDF

Les étapes suivantes montrent comment optimiser un document PDF en réduisant sa taille tout en conservant la 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 FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfManager.Optimize(options);

Principales fonctionnalités :

• Optimisation : Réduire la taille du fichier PDF sans perdre en qualité.

Redimensionner les pages PDF

Vous pouvez redimensionner les pages des documents PDF en utilisant la classe PDF Manager. Après avoir créé un ResizeOptions, vous pouvez définir la taille de page souhaitée et lancer le processus de redimensionnement. Le PDF résultant reflétera les nouvelles dimensions, assurant qu’il correspond aux exigences spécifiques.

Redimensionner le 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  
 2// Create ResizeOptions object to set instructions  
 3var options = new ResizeOptions();  
 4// Set new PageSize  
 5options.PageSize = PageSize.A3;  
 6// Add input file path  
 7options.AddInput(new FileData("path_to_your_pdf_file.pdf"));  
 8// Set output file path  
 9options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));  
10// Perform the process  
11PdfManager.Resize(options);  

Fonctionnalités clés :

• Redimensionnement : Redimensionner les pages à des dimensions spécifiques
• Tailles disponibles : A0, A1, A2, A3, A4, A4, A5, A6, B5, Letter, Legal, Ledger, 11x17 inches.

Ajouter un tableau

Le Documentize PDF Manager pour .NET est un composant polyvalent conçu pour simplifier l’intégration de tableaux dans les documents PDF. Que vous organisiez des données, conceviez des formulaires ou amélioriez la lisibilité d’un document, ce composant simplifie le processus tout en garantissant précision et efficacité.

Création d’un PDF avec des tableaux

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

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

Voici un exemple :

 1// Configure table options
 2var options = new TableOptions();
 3options.InsertPageBefore(1)
 4   .AddTable()
 5        .AddRow()
 6            .AddCell().AddParagraph("Name")
 7            .AddCell().AddParagraph("Age")
 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// Add input file path
24options.AddInput(new FileData("path_to_input.pdf"));
25// Set output file path
26options.AddOutput(new FileData("path_to_output.pdf"));
27// Perform the process
28PdfManager.AddTable(options);

Définir la page du tableau

Suivez ces étapes pour créer un tableau dans un PDF avant la page 2 : Voici un exemple :

 1// Configure table options
 2var options = new TableOptions();
 3options.InsertPageBefore(2) // Add table before page 2
 4   .AddTable()
 5        .AddRow()
 6            .AddCell().AddParagraph("Name")
 7            .AddCell().AddParagraph("Age");
 8// Add input file path
 9options.AddInput(new FileData("path_to_input.pdf"));
10// Set output file path
11options.AddOutput(new FileData("path_to_output.pdf"));
12// Perform the process
13PdfManager.AddTable(options);

Fonctionnalités clés :

• Création dynamique de tableaux : générez facilement des tableaux structurés dans les documents PDF.
• Placement sur page : insérez des tableaux à des emplacements précis dans un PDF.
• Mise en page personnalisable : ajustez la structure du tableau, l’alignement des cellules et le style.

Ajouter une table des matières

Le Documentize PDF Manager for .NET est un composant 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 composant simplifie le processus d’ajout de tables des matières à vos PDF, 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 à l’aide de la propriété Title.
3. Concevez les en-têtes de la TOC avec la méthode Headings.Add.
4. Ajoutez le fichier PDF d’entrée avec la méthode AddInput.
5. Spécifiez le fichier PDF de sortie contenant la TOC avec la méthode AddOutput.
6. Appelez la méthode AddTableOfContents pour générer la TOC.

 1// Create TocOptions object to set instructions
 2var options = new TocOptions();
 3// Set the Title
 4options.Title = "My Table of Contents";
 5// Design Headings
 6options.Headings.Add(new TocHeading("Introduction", 2));
 7options.Headings.Add(new TocHeading("Chapter I", 3));
 8options.Headings.Add(new TocHeading("Chapter II", 4));
 9options.Headings.Add(new TocHeading("Chapter III", 5));
10// Add input file path
11options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
12// Set output file path
13options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
14// Perform the process
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// Create TocOptions object to set instructions
 2var options = new TocOptions();
 3// Set the Title
 4options.Title = "My Table of Contents";
 5// Generate links in bookmarks
 6options.GenerateBookmarks = true;
 7// Design Headings
 8options.Headings.Add(new TocHeading("Introduction", 2, false, 1));
 9options.Headings.Add(new TocHeading("Chapter I", 3, true, 1));
10options.Headings.Add(new TocHeading("Chapter II", 4, true, 1));
11options.Headings.Add(new TocHeading("Example A", 4, true, 2));
12options.Headings.Add(new TocHeading("Example B", 4, true, 2));
13options.Headings.Add(new TocHeading("Example C", 4, true, 2));
14options.Headings.Add(new TocHeading("Example D", 4, true, 2));
15options.Headings.Add(new TocHeading("Chapter III", 5, true, 1));
16// Add input file path
17options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
18// Set output file path
19options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
20// Perform the process
21PdfManager.AddTableOfContents(options);

Comment obtenir le résultat sous forme de flux

 1// Create TocOptions object to set instructions
 2var options = new TocOptions();
 3// Set the Title
 4options.Title = "My Table of Contents";
 5// Design Headings
 6options.Headings.Add(new TocHeading("Introduction", 2, false, 1));
 7// Add input file path
 8options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 9// Set output stream 
10var outputStream = new MemoryStream();
11options.AddOutput(new StreamData(outputStream));
12options.CloseOutputStreams = false;
13// Perform the process
14PdfManager.AddTableOfContents(options);

Personnaliser 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.

 1// Create TocOptions object to set instructions
 2var heading = new TocHeading();
 3heading.Text = "Intro";
 4heading.PageNumber = 5;
 5heading.GenerateNumbering = true;
 6heading.Level = 2;
 7var tocOptions = new TocOptions();
 8options.Headings.Add(heading);
 9// Add input and output files
10tocOptions.AddInput(new FileData("path_to_your_pdf_file.pdf"));
11tocOptions.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
12// Generate the TOC with customized options
13PdfManager.AddTableOfContents(tocOptions);

Principales fonctionnalités :

• Génération dynamique de TOC : Créez une table des matières pour n’importe quel fichier PDF avec des entrées générées automatiquement à partir 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 : Réduisez le temps passé à créer manuellement des tables des matières, surtout pour les documents volumineux ou complexes.

Use ChatGPT

Le Documentize PDF Manager for .NET plug-in est un outil puissant conçu pour intégrer l’API ChatGPT aux applications PDF. Ce plug-in permet aux développeurs de générer des réponses de chat à partir de messages d’entrée et d’enregistrer le résultat 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 enregistrer dans un fichier PDF à l’aide du plug‑in ChatGPT, suivez ces étapes :

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

 1var options = new ChatGptRequestOptions();
 2// Set output file path
 3options.AddOutput(new FileData("path_to_result_pdf_file.pdf")); 
 4options.ApiKey = "Your API key."; // You need to provide the key to access the API.
 5options.MaxTokens = 1000; // The maximum number of tokens to generate in the chat completion.
 6
 7// Add the request messages.
 8options.Messages.Add(new Message
 9{
10    Content = "You are a helpful assistant.",
11    Role = Role.System
12});
13options.Messages.Add(new Message
14{
15    Content = "What is the biggest pizza diameter ever made?",
16    Role = Role.User
17});
18
19// Process the request.
20var result = await PdfManager.CreatePdfByChatGptRequestAsync(options);
21
22var fileResultPath = result.ResultCollection[0].Data;
23var chatCompletionObject = result.ResultCollection[1].Data as ChatCompletion; // The ChatGPT API chat completion object.

Ajout de messages système et utilisateur

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

1. Ajoutez un message système qui fixe 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// Set output file path
 3options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 4
 5// Add the PDF text source.
 6// In case of multiple sources, the text from each document will be added to the request message collection
 7// as a separate message with the role "user".
 8options.AddInput(new FileData("TextSource.pdf"));
 9
10options.ApiKey = "Your API key."; // You need to provide the key to access the API.
11options.MaxTokens = 1000; // The maximum number of tokens to generate in the chat completion.
12
13// Add the request message.
14// In this case, the system message with Content = "You are a helpful assistant." is added by default.
15// The role of the query message is "user" by default.
16options.Query = "How many letters in the provided text?";
17
18// Process the request.
19var result = await PdfManager.CreatePdfByChatGptRequestAsync(options);
20
21var fileResultPath = result.ResultCollection[0].Data;
22var chatCompletionObject = result.ResultCollection[1].Data as ChatCompletion; // The ChatGPT API chat completion object.

Principales fonctionnalités :

• Chat Completions : Générer des réponses à l’aide de l’API ChatGPT en fonction d’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 : Enregistrer les complétions de chat générées dans un fichier PDF structuré pour une utilisation ultérieure.
• Traitement asynchrone : Garantir des applications réactives en traitant les complétions de chat de façon asynchrone.

Encrypt

Le Documentize PDF Security for .NET est un outil puissant conçu pour renforcer la sécurité de vos documents PDF en offrant des capacités de chiffrement, de déchiffrement et de signature. Il garantit que vos informations sensibles restent confidentielles et protégées contre tout accès non autorisé.

Comment chiffrer un PDF

Pour chiffrer un document PDF, suivez ces étapes :

1. Créez une instance de EncryptOptions avec les mots de passe utilisateur et propriétaire souhaités.
2. Ajoutez le fichier PDF d’entrée à l’aide de la méthode AddInput.
3. Ajoutez le fichier PDF de sortie à l’aide de la méthode AddOutput.
4. Exécutez le chiffrement à l’aide de la méthode Encrypt de la classe PdfSecurity.

1// Create EncryptOptions object to set instructions
2var options = new EncryptOptions("123456", "qwerty");
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfSecurity.Encrypt(options);

Fonctionnalités principales :

• Chiffrer les documents PDF : Sécurisez vos fichiers PDF en ajoutant des mots de passe utilisateur et propriétaire.

• Automatisation : Intégrez le chiffrement et le déchiffrement dans vos applications .NET pour des flux de travail automatisés.
• Conformité : Assurez-vous que vos documents respectent les normes industrielles en matière de sécurité des documents.

Déchiffrer

Le Documentize PDF Security for .NET est un outil puissant conçu pour renforcer la sécurité de vos documents PDF en offrant des capacités de chiffrement, de déchiffrement et de signature. Il garantit que vos informations sensibles restent confidentielles et protégées contre tout accès non autorisé.

Comment déchiffrer un PDF

Pour déchiffrer un document PDF, suivez ces étapes :

1. Créez une instance de DecryptionOptions avec le mot de passe nécessaire.
2. Ajoutez le fichier PDF d’entrée à l’aide de la méthode AddInput.
3. Ajoutez le fichier PDF de sortie à l’aide de la méthode AddOutput.
4. Exécutez le déchiffrement en utilisant la méthode Decrypt de la classe PdfSecurity.

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

Principales fonctionnalités :

• Déchiffrer les documents PDF : Supprimez le chiffrement des PDF lorsque cela est nécessaire.
• Automatisation : Intégrez le chiffrement et le déchiffrement dans vos applications .NET pour des flux de travail automatisés.
• Conformité : Assurez‑vous que vos documents respectent les normes industrielles en matière de sécurité des documents.

Signer

Le composant Documentize PDF Security for .NET permet aux utilisateurs de signer numériquement des documents PDF. Il offre un processus simplifié pour ajouter des signatures, garantir l’authenticité et sécuriser le contenu des PDF. Le composant prend en charge les signatures visibles et invisibles et propose des options pour personnaliser la position de la signature, le motif, les coordonnées de contact, etc.

Comment signer des documents PDF

Pour signer un document PDF à l’aide d’un fichier PFX, suivez ces étapes :

1. Instanciez la classe SignOptions avec le chemin du fichier PFX et le mot de passe.
2. Ajoutez le PDF d’entrée et le fichier de sortie aux options.
3. Exécutez la méthode Sign pour appliquer la signature.

1 // Create SignOptions object to set instructions
2 var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
3 // Add input file path
4 options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5 // Set output file path
6 options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7 // Perform the process
8 PdfSecurity.Sign(options);

Comment utiliser un flux (Stream) pour le fichier PFX

Vous pouvez également signer un PDF en fournissant le certificat PFX sous forme de flux au lieu d’un chemin de fichier. Cela permet une gestion plus flexible du stockage du certificat.

1 using var pfxStream = File.OpenRead(@"path_to_your_pfx_file.pfx");
2 var options = new SignOptions(pfxStream, "password_of_your_pfx_file");
3 options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
4 options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
5 // Perform the process
6 PdfSecurity.Sign(options);

Comment appliquer des signatures invisibles

Pour ajouter une signature invisible (qui sécurise le document sans afficher la signature), il suffit de définir la propriété Visible sur false.

1. Créez une instance de SignOptions.
2. Réglez Visible sur false.
3. Ajoutez les fichiers d’entrée et de sortie.
4. Appelez Sign pour appliquer la signature invisible.

1 var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
2 options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
3 options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
4 // Configure invisible signature
5 signOptions.Visible = false;
6 // Perform the process
7 PdfSecurity.Sign(options);

Comment utiliser des options supplémentaires pour la signature de documents PDF

Vous pouvez spécifier des options supplémentaires lors de l’ajout d’une signature à un fichier PFX, telles que le motif, le contact, l’emplacement, le numéro de page.

1. Instanciez la classe SignOptions avec le chemin du fichier PFX et le mot de passe.
2. Ajoutez le PDF d’entrée et le fichier de sortie aux options.
3. Définissez les valeurs de vos options.
4. Exécutez la méthode Sign pour appliquer la signature.

 1 // Create SignOptions object to set instructions
 2 var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
 3 // Add input file path
 4 options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5 // Set output file path
 6 options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 7 // Optional parameters
 8 options.Reason = "my Reason";
 9 options.Contact = "my Contact";
10 options.Location = "my Location";
11 options.PageNumber = 3;
12 // Perform the process
13 PdfSecurity.Sign(options);

Comment ajouter un horodatage à un PDF

Pour ajouter un horodatage sécurisé à un document PDF, suivez ces étapes :

1. Créez une instance de AddTimestampOptions pour configurer le processus d’horodatage.
2. Ajoutez le fichier PDF d’entrée à l’aide de la méthode AddInput.
3. Définissez le chemin du fichier de sortie avec AddOutput.
4. Exécutez l’horodatage en appelant la méthode Sign.

1 // Create SignOptions object to set instructions
2 var options = new SignOptions("path_to_your_pfx_file.pfx", "password_for_your_pfx_file");
3 options.TimestampOptions = new TimestampOptions("server_url");
4 // Add input file path
5 options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
6 // Set output file path
7 options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
8 // Perform the process
9 PdfSecurity.Sign(options);

Comment utiliser une authentification personnalisée avec le serveur d’horodatage

Vous pouvez fournir des identifiants d’authentification de base lors de la connexion au serveur d’horodatage. Cela vous permet de vous authentifier auprès de serveurs qui exigent un nom d’utilisateur et un mot de passe.

1 // Configure the timestamping options with authentication
2 options.TimestampOptions = new TimestampOptions("timestamp_server_url", "username:password");

Principales fonctionnalités :

• Signer numériquement des documents PDF : sécurisez vos documents avec des signatures digitales visibles ou invisibles.
• Prise en charge du PFX : signez des fichiers PDF en utilisant un certificat PFX.
• Options personnalisables : configurez les paramètres de signature tels que le motif, l’emplacement et les coordonnées de contact.
• Signatures visibles et invisibles : choisissez si la signature apparaît ou non sur le document.
• Serveurs d’horodatage personnalisables : utilisez des URL de serveur d’horodatage personnalisées et des informations d’authentification.

Aplatir les champs de formulaire

Le Documentize PDF Form for .NET vous permet de convertir les formulaires PDF interactifs en documents non modifiables, les rendant sécurisés contre les modifications non autorisées. Cet outil transforme les champs de formulaire en contenu statique, renforçant la sécurité de vos documents PDF. Il est particulièrement utile lorsque vous devez sécuriser des contrats, des accords ou tout document dont les champs doivent rester inchangés.

Comment aplatir les champs de formulaire dans un PDF

Pour aplatir les champs de formulaire dans un document PDF, suivez ces étapes :

1. Créez une instance de la classe FlattenFieldsOptions.
2. Ajoutez les fichiers d’entrée et de sortie aux options.
3. Appelez la méthode Flatten pour effectuer l’opération d’aplatissement.

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

Comment obtenir tous les champs d’un PDF

Vous pouvez récupérer des informations sur le nombre de champs contenus dans un document.

1// Get Fields Names
2var fieldNames = PdfForm.GetNames(new GetFieldNamesOptions("path_to_your_pdf_file.pdf"));

Comment aplatir tout sauf le premier champ d’un PDF

Vous pouvez aplatir sélectivement uniquement certains champs de formulaire selon des critères tels que la position ou le nom du champ.

 1// Get Fields Names
 2var fieldNames = PdfForm.GetNames(new GetFieldNamesOptions("path_to_your_pdf_file.pdf"));
 3// Create FlattenFieldsOptions object to set instructions
 4var options = new FlattenFieldsOptions();
 5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 7// Skip 1 field.
 8options.SkipFields.Add(fieldNames[0]);
 9// Perform the process
10PdfForm.Flatten(options);

Fonctionnalités clés :

• Aplatir tous les champs de formulaire : Convertit les champs de formulaire interactifs en contenu statique non modifiable.
• Obtenir les noms des champs : Récupère les noms des champs dans un PDF.
• Aplatir des champs sélectionnés : Permet d’aplatir spécifiquement certains champs d’un PDF tout en laissant les autres modifiables.