PDF to HTML

Le Convertisseur PDF de Documentize pour .NET offre des capacités robustes pour convertir des documents PDF en format HTML, idéal pour les applications web, l’archivage et la génération de rapports. Avec plusieurs options pour gérer les ressources et les mises en page, le convertisseur s’adapte à divers besoins de projet.

Conversion de PDF en HTML

Convertissez des fichiers PDF en HTML pour rendre les documents accessibles pour une visualisation basée sur le web ou une intégration dans des applications où le format HTML est préféré.

1. Configurer les Options : Utilisez PdfToHtmlOptions pour personnaliser la sortie, en choisissant soit des ressources intégrées, soit des ressources externes.
2. Définir les Chemins d’Entrée et de Sortie : Définissez les chemins pour votre PDF d’entrée et votre HTML de sortie.
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// Créer un objet PdfToHtmlOptions pour définir le type de données de sortie comme fichier avec des ressources intégrées
2var options = new PdfToHtmlOptions(PdfToHtmlOptions.SaveDataType.FileWithEmbeddedResources);
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_input.pdf"));
5// Définir le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_output.html"));
7// Effectuer le processus
8PdfConverter.Convert(options);

Options Disponibles pour la Conversion de PDF en HTML

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

PDF to DOC

Le Convertisseur PDF Documentize pour .NET est un puissant outil conçu pour convertir des documents PDF en formats DOC ou DOCX. Ce plugin transforme sans effort les pages PDF en documents Microsoft Word modifiables, facilitant ainsi la réutilisation, la modification et le partage de contenu sur plusieurs plateformes.

Comment convertir PDF en DOC/DOCX

Pour convertir un document PDF en format DOC/DOCX, suivez ces étapes :

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

1// Créer un objet PdfToDocOptions pour définir les instructions
2var options = new PdfToDocOptions();
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Définir le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_result_file.doc"));
7// Effectuer le processus
8PdfConverter.Convert(options);

Conversion de PDF en DOC avec Options Personnalisées

Le plugin Convertisseur PDF en DOC fournit plusieurs options pour personnaliser votre processus de conversion. Vous pouvez choisir entre différents modes pour contrôler comment la mise en page et la structure du PDF sont gérées lors de la conversion.

 1// Créer un objet PdfToDocOptions pour définir les instructions
 2var options = new PdfToDocOptions();
 3// Ajouter le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
 5// Définir le chemin du fichier de sortie
 6options.AddOutput(new FileDataSource("path_to_result_file.doc"));
 7// Définir le Mode
 8options.Mode = DocConversionMode.Flow;
 9// Effectuer le processus
10PdfConverter.Convert(options);

Fonctionnalités Clés:

• Conversion DOC/DOCX : Convertir des documents PDF en formats Word modifiables (DOC ou DOCX).
• Maintenir la Mise en Forme : Conserver la mise en page, le texte et la mise en forme d’origine pendant le processus de conversion.
• Options de Conversion Personnalisées : Affinez le processus de conversion avec différents modes, comme Enhanced Flow, pour une meilleure mise en page.

HTML to PDF

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

Conversion de HTML en PDF

Transformez le contenu HTML en PDFs de haute qualité, parfaits 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 : Définissez les chemins des fichiers HTML d’entrée et PDF de sortie.
3. Exécuter la Conversion : Exécutez la méthode Convert de PdfConverter pour convertir le fichier.

Exemple : Convertir HTML en PDF

1// Créer HtmlToPdfOptions
2var options = new HtmlToPdfOptions();
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_input.html"));
5// Définir le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_output.pdf"));
7//Exécuter le processus
8PdfConverter.Convert(options);

Options Supplémentaires pour la Conversion de HTML en PDF

• Type de Média :

  • HtmlMediaType.Print : Idéal pour générer des PDFs adaptés à l’impression.
  • HtmlMediaType.Screen : À utiliser lors de la conversion de contenu conçu pour la visualisation numérique.

• Ajustements de Mise en Page :

  • PageLayoutOption : Ajuste comment le contenu HTML s’adapte à la mise en page PDF, comme ScaleToPageWidth pour s’assurer que le contenu s’adapte à 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 une variété d’applications, de la génération de rapports PDF basés sur du contenu web à la conversion d’archives de documents PDF pour l’accessibilité web. Pour des configurations plus avancées, consultez la documentation complète de Documentize.

PDF to JPEG

Le Convertisseur PDF Documentize pour .NET est un outil puissant qui simplifie la conversion de documents PDF en images JPEG de haute qualité. Ce plugin est conçu pour rendre votre contenu plus accessible sur différentes 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// Créer un objet PdfToJpegOptions pour définir les instructions
2var options = new PdfToJpegOptions();
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_input.pdf"));
5// Définir le chemin du répertoire de sortie
6options.AddOutput(new DirectoryDataSource("path_to_output_directory"));
7// Effectuer le processus
8PdfConverter.Convert(options);

Personnalisation de 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// Créer un objet PdfToJpegOptions pour définir les instructions
 2var options = new PdfToJpegOptions();
 3// Traiter seulement la première page
 4options.PageList = [1];
 5// Définir la résolution de sortie à 200 DPI
 6options.OutputResolution = 200;
 7// Définir la qualité de sortie à 50
 8options.Quality = 50;
 9// Ajouter le chemin du fichier d'entrée
10options.AddInput(new FileDataSource("path_to_input.pdf"));
11// Définir le chemin du répertoire de sortie
12options.AddOutput(new DirectoryDataSource("path_to_output_directory"));
13// Effectuer le processus
14PdfConverter.Convert(options);

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

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

 1// Créer un objet PdfToJpegOptions pour définir les instructions
 2var options = new PdfToJpegOptions();
 3// Ajouter le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("path_to_input.pdf"));
 5// Effectuer le processus
 6var results = PdfConverter.Convert(options);
 7// Obtenir les résultats des flux
 8foreach (var result in results.ResultCollection)
 9{
10    var streamResultPage1 = result.ToStream();
11}

Caractéristiques clés :

• Convertir PDF en JPEG : Convertissez sans effort des documents PDF entiers 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 minimum d’effort.

PDF to PDF/A

Le Convertisseur PDF Documentize pour .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 plugin 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 seule solution.

Comment convertir un PDF en PDF/A

Pour convertir un document PDF en 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 exemple, PDF/A-3B).
3. Ajoutez le fichier PDF d’entrée en utilisant la méthode AddInput.
4. Ajoutez le fichier de sortie pour le PDF/A résultant en utilisant la méthode AddOutput.
5. Appelez la méthode Convert pour exécuter la conversion.

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

Validation de la conformité PDF/A

Vous pouvez valider des fichiers PDF existants pour la conformité PDF/A en utilisant la classe PdfAValidateOptions.

 1// Créer la classe d'options pour configurer le processus de validation
 2var options = new PdfAValidateOptions
 3{
 4    PdfAVersion = PdfAStandardVersion.PDF_A_1A
 5};
 6
 7// Ajouter un ou plusieurs fichiers à valider
 8options.AddInput(new FileDataSource("path_to_your_first_pdf_file.pdf")); // remplacez par le chemin de votre fichier réel
 9options.AddInput(new FileDataSource("path_to_your_second_pdf_file.pdf"));
10// ajoutez d'autres fichiers si nécessaire
11
12// Exécuter la validation et obtenir les résultats
13var resultContainer = PdfConverter.Validate(options);
14
15// Vérifiez la propriété resultContainer.ResultCollection pour les résultats de validation pour chaque fichier :
16for (var i = 0; i < resultContainer.ResultCollection.Count; i++)
17{
18    var result = resultContainer.ResultCollection[i];
19    var validationResult = (PdfAValidationResult) result.Data;
20    var isValid = validationResult.IsValid; // Résultat de validation pour le i-ème document
21}

Caractéristiques clés :

• Convertir en PDF/A : Transformez sans effort des 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.
• Valider la conformité PDF/A : Vérifiez les documents PDF existants pour leur conformité aux normes PDF/A et identifiez les problèmes s’ils ne sont pas conformes.
• Flux de travail efficace : Minimisez le temps et les efforts avec des processus de conversion rapides et fiables.

PDF to PNG

Le Convertisseur PDF de Documentize pour .NET est un outil avancé qui vous permet de convertir des documents PDF en images PNG de haute qualité. Ce plugin est conçu pour rendre votre contenu plus polyvalent, accessible et 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 en utilisant la méthode AddInput.
3. Définissez le chemin du répertoire de sortie pour les images PNG en utilisant la méthode AddOutput.
4. Exécutez la méthode Convert pour convertir les pages PDF en images PNG.

1// Créer un objet PdfToPngOptions pour définir les instructions
2var options = new PdfToPngOptions();
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_input.pdf"));
5// Définir le chemin du répertoire de sortie
6options.AddOutput(new DirectoryDataSource("path_to_output_directory"));
7// Exécuter le processus
8PdfConverter.Convert(options);

Personnaliser 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 convertir uniquement la première page d’un PDF à 200 DPI :

 1// Créer un objet PdfToPngOptions pour définir les instructions
 2var options = new PdfToPngOptions()
 3// Traiter uniquement la première page
 4options.PageList = [1];
 5// Définir la résolution de sortie à 200 DPI
 6options.OutputResolution = 200;
 7// Ajouter le chemin du fichier d'entrée
 8options.AddInput(new FileDataSource("path_to_input.pdf"));
 9// Définir le chemin du répertoire de sortie
10options.AddOutput(new DirectoryDataSource("path_to_output_directory"));
11// Exécuter le processus
12PdfConverter.Convert(options);

Gestion des résultats de conversion

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

 1// Créer un objet PdfToJpegOptions pour définir les instructions
 2var options = new PdfToPngOptions();
 3// Ajouter le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("path_to_input.pdf"));
 5// Exécuter le processus
 6var results = PdfConverter.Convert(options);
 7// Obtenir les résultats de flux
 8foreach (var result in results.ResultCollection)
 9{
10    var streamResultPage1 = result.ToStream();
11}

Caractéristiques clé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 exemple, 300 DPI) pour une sortie d’image de haute qualité.
• Ensemble de pages : Sélectionnez des pages spécifiques pour la conversion.
• Gestion facile des sorties : Spécifiez des répertoires de sortie pour chaque fichier PNG converti.
• Conversion rapide : Rapide, efficace, et nécessite un minimum d’effort pour la configuration.

PDF to TIFF

Le Convertisseur PDF Documentize pour .NET est un outil puissant conçu pour convertir des documents PDF en images TIFF de haute qualité. Ce plugin garantit que votre contenu est accessible sur diverses plateformes tout en maintenant 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 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 en utilisant la méthode AddInput.
3. Spécifiez le chemin du fichier de sortie pour les images TIFF en utilisant la méthode AddOutput.
4. Exécutez la méthode Convert pour convertir les pages PDF en images TIFF.

1// Créer un objet PdfToTiffOptions pour définir les instructions
2var options = new PdfToTiffOptions();
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("chemin_vers_votre_fichier_pdf.pdf"));
5// Définir le chemin du répertoire de sortie
6options.AddOutput(new DirectoryDataSource("chemin_vers_répertoire_de_sortie"));
7// Effectuer le processus
8PdfConverter.Convert(options);

Personnalisation des pages et DPI de la conversion PDF en TIFF

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

 1// Créer un objet PdfToTiffOptions pour définir les instructions
 2var options = new PdfToTiffOptions();
 3// Ajouter le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("chemin_vers_votre_fichier_pdf.pdf"));
 5// Définir le chemin du répertoire de sortie
 6options.AddOutput(new DirectoryDataSource("chemin_vers_répertoire_de_sortie"));
 7// Définir les pages
 8options.PageList = [1, 3];
 9// Définir la résolution de l'image résultante
10options.OutputResolution = 400;
11// Effectuer le processus
12PdfConverter.Convert(options);

Création de TIFF multi-pages

Le plugin 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 efficace.

 1// Créer un objet PdfToTiffOptions pour définir les instructions
 2var options = new PdfToTiffOptions();
 3// Ajouter le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("chemin_vers_votre_fichier_pdf.pdf"));
 5// Définir le chemin du répertoire de sortie
 6options.AddOutput(new DirectoryDataSource("chemin_vers_répertoire_de_sortie"));
 7// Activer la sortie TIFF multi-pages
 8options.MultiPage = true;
 9// Effectuer le processus
10PdfConverter.Convert(options);

Personnalisation des pages et DPI de la conversion PDF en TIFF

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

 1// Créer un objet PdfToTiffOptions pour définir les instructions
 2var options = new PdfToTiffOptions();
 3// Ajouter le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("chemin_vers_votre_fichier_pdf.pdf"));
 5// Définir le chemin du répertoire de sortie
 6options.AddOutput(new DirectoryDataSource("chemin_vers_répertoire_de_sortie"));
 7// Définir la compression et la profondeur de couleur
 8options.Compression = TiffCompression.RLE;
 9options.ColorDepth = TiffColorDepth.Format24bpp;
10// Effectuer le processus
11PdfConverter.Convert(options);

Comment gérer les résultats de conversion

La méthode Convert retourne 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// Créer un objet PdfToTiffOptions pour définir les instructions
 2var options = new PdfToTiffOptions();
 3// Ajouter le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("chemin_vers_input.pdf"));
 5// Effectuer le processus
 6var results = PdfConverter.Convert(options);
 7// Obtenir les résultats de flux
 8foreach (var result in results.ResultCollection)
 9{
10    var streamResultPage1 = result.ToStream();
11}

Caractéristiques clés :

• Convertir PDF en TIFF : Convertissez sans effort des documents PDF entiers ou des pages spécifiques en images TIFF.
• Résolution personnalisée : Ajustez la résolution (par exemple, 300 dpi) pour des sorties de qualité supérieure.
• TIFF multi-pages : Combinez plusieurs pages PDF en un seul fichier TIFF multi-pages.
• Ensemble de pages : Sélectionnez des pages spécifiques pour la conversion.
• Conversion rapide : Processus rapide et efficace avec un effort minimal.

PDF to XLS

Le Convertisseur PDF de Documentize pour .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 plugin, les développeurs peuvent transformer sans effort les données PDF statiques en feuilles de calcul dynamiques et modifiables, simplifiant ainsi 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 en utilisant la classe PdfToXlsOptions.
2. Ajoutez des fichiers PDF d’entrée en utilisant la méthode AddInput.
3. Spécifiez le chemin du fichier de sortie en utilisant la méthode AddOutput.
4. Exécutez la méthode Convert pour initier la conversion.

1// Créez un objet PdfToXlsOptions pour définir les instructions
2var options = new PdfToXlsOptions();
3// Ajoutez le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Définissez le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_result_xlsx_file.xlsx"));
7// Effectuez le processus
8PdfConverter.Convert(options);

Personnalisation de la conversion PDF en Excel

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

 1// Créez un objet PdfToXlsOptions pour définir les instructions
 2var options = new PdfToXlsOptions();
 3// Ajoutez le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
 5// Spécifiez le format XLS
 6options.Format = PdfToXlsOptions.ExcelFormat.XMLSpreadSheet2003;
 7options.InsertBlankColumnAtFirst = true;
 8options.MinimizeTheNumberOfWorksheets = true;
 9// Définissez le chemin du fichier de sortie
10options.AddOutput(new FileDataSource("path_to_result_xlsx_file.xls"));
11// Effectuez le processus
12PdfConverter.Convert(options);

Formats de sortie pris en charge

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

• XLSX : Format de fichier Office Open XML (.xlsx) (par défaut).
• XLSM : Format Excel avec macro activée.
• CSV : Valeurs séparées par des virgules.
• ODS : Feuille de calcul Open Document.
• XMLSpreadSheet2003 : Format de fichier XML Excel 2003 (.xls).

Caractéristiques clés :

• Options de conversion flexibles : Convertissez des fichiers PDF en XLSX, XLS, CSV ou d’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 minimisez le nombre de feuilles de calcul.

Extract Text

Le Documentize PDF Extractor pour .NET simplifie l’extraction de texte des 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 la mise en forme ou en l’omettant selon vos besoins.

Comment extraire le texte d’un PDF

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

1. Créez une instance de ExtractTextOptions pour configurer les options d’extraction.
2. Ajoutez le fichier PDF d’entrée en utilisant la méthode AddInput.
3. Exécutez la méthode ExtractText pour extraire le texte.
4. Accédez au texte extrait en utilisant ResultContainer.ResultCollection.

1// Créer un objet ExtractTextOptions pour définir des instructions
2var options = new ExtractTextOptions();
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Exécuter le processus
6var results = PdfExtractor.ExtractText(options);
7// Obtenir le texte extrait de l'objet ResultContainer
8var textExtracted = results.ResultCollection[0].ToString();

Modes d’extraction de texte

Les ExtractTextOptions offrent trois modes d’extraction, fournissant de la flexibilité en fonction de vos besoins.

1. Mode Pur : Préserve la mise en forme originale, y compris les espaces et l’alignement.
2. Mode Brut : Extrait le texte sans mise en forme, utile pour le traitement de données brutes.
3. Mode Aplati : Représente le contenu PDF en positionnant les fragments de texte par leurs coordonnées.

1// Créer un objet ExtractTextOptions pour définir TextFormattingMode
2var options = new ExtractTextOptions(TextFormattingMode.Pure);
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Exécuter le processus
6var results = PdfExtractor.ExtractText(options);
7// Obtenir le texte extrait de l'objet ResultContainer
8var textExtracted = results.ResultCollection[0].ToString();

Caractéristiques clés:

• Mode Pur : Extraire le texte tout en préservant sa mise en forme originale.
• Mode Brut : Extraire le texte sans aucune mise en forme.
• Mode Aplati : Extraire 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 des documents PDF. Il scanne vos fichiers PDF, identifie les images intégrées et les extrait tout en préservant leur qualité et leur format d’origine. Cet outil améliore l’accessibilité du contenu visuel et rationalise le processus de récupération des images dans les 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 en utilisant la méthode AddInput.
3. Définissez le chemin du répertoire de sortie pour les images avec la méthode AddOutput.
4. Traitez l’extraction d’image en utilisant le plugin.
5. Récupérez les images extraites du conteneur de résultats.

 1  
 2// Créer ExtractImagesOptions pour définir les instructions  
 3var options = new ExtractImagesOptions();  
 4// Ajouter le chemin du fichier d'entrée  
 5options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));  
 6// Définir le chemin du répertoire de sortie  
 7options.AddOutput(new DirectoryDataSource("path_to_results_directory"));  
 8// Effectuer le processus  
 9var results = PdfExtractor.ExtractImages(options);  
10// Obtenir le chemin du résultat d'image  
11var imageExtracted = results.ResultCollection[0].ToFile();  

Extraction d’Images d’un Fichier PDF vers des Flux sans Dossier

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

 1  
 2// Créer ExtractImagesOptions pour définir les instructions  
 3var options = new ExtractImagesOptions();  
 4// Ajouter le chemin du fichier d'entrée  
 5options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));  
 6// Pas de sortie définie - il écrira les résultats vers des flux  
 7// Effectuer le processus  
 8var results = PdfExtractor.ExtractImages(options);  
 9// Obtenir le flux  
10var ms = results.ResultCollection[0].ToStream();  
11// Copier les données dans un fichier pour la démo  
12ms.Seek(0, SeekOrigin.Begin);  
13using (var fs = File.Create("test_file.png"))  
14{  
15    ms.CopyTo(fs);  
16}  

Caractéristiques Principales :

• Extraire des Images Intégrées : Identifier et extraire des images des documents PDF.
• Préserver la Qualité des Images : Assure que les images extraites conservent leur qualité d’origine.
• Sortie Flexible : Enregistrez les images extraites dans votre format ou emplacement préféré.

Export Form Data

Le plugin Documentize PDF Extractor for .NET offre un moyen fluide d’extraire et d’exporter des données à partir de formulaires PDF (AcroForms) vers d’autres formats comme 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 des données aisés.

Comment exporter des données de formulaire depuis un PDF

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

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

1// Créez un objet ExtractFormDataToDsvOptions pour définir les instructions
2var options = new ExtractFormDataToDsvOptions(',', true);
3// Ajoutez le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Définissez le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_result_csv_file.csv"));
7// Exécutez le processus
8PdfExtractor.ExtractFormData(options);

Caractéristiques clés :

• Exporter des données de formulaire : Extraire des données à partir de formulaires PDF (AcroForms) vers CSV ou d’autres formats.
• Filtrage des données : Utilisez des prédicats pour filtrer des champs de formulaire spécifiques pour l’exportation en fonction de critères tels que le type de champ ou le numéro de page.
• Sortie flexible : Enregistrez les données exportées pour analyse ou transfert vers des tableurs, bases de données ou d’autres formats de documents.

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.

Encrypt

La sécurité PDF de Documentize pour .NET est un outil puissant conçu pour améliorer la sécurité de vos documents PDF en offrant des capacités de cryptage, de décryptage et de signature. Il garantit que vos informations sensibles restent confidentielles et protégées contre les accès non autorisés.

Comment crypter un PDF

Pour crypter 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 en utilisant la méthode AddInput.
3. Ajoutez le fichier PDF de sortie en utilisant la méthode AddOutput.
4. Exécutez le cryptage en utilisant la méthode Encrypt de la classe PdfSecurity.

1// Créez un objet EncryptOptions pour définir les instructions
2var options = new EncryptOptions("123456", "qwerty");
3// Ajoutez le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Définissez le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
7// Effectuez le processus
8PdfSecurity.Encrypt(options);

Caractéristiques clés :

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

• Automatisation : Intégrez le cryptage et le décryptage dans vos applications .NET pour des flux de travail automatisés.
• Conformité : Assurez-vous que vos documents répondent aux normes de l’industrie en matière de sécurité des documents.

Decrypt

Le Documentize PDF Security for .NET est un outil puissant conçu pour améliorer la sécurité de vos documents PDF en fournissant 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éer une instance de DecryptionOptions avec le mot de passe nécessaire.
2. Ajouter le fichier PDF d’entrée en utilisant la méthode AddInput.
3. Ajouter le fichier PDF de sortie en utilisant la méthode AddOutput.
4. Exécuter le déchiffrement en utilisant la méthode Decrypt de la classe PdfSecurity.

1// Créer un objet DecryptOptions pour définir les instructions
2var options = new DecryptOptions("123456");
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Définir le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
7// Effectuer le processus
8PdfSecurity.Decrypt(options);

Fonctionnalités clés :

• Déchiffrer des documents PDF : Supprimer le chiffrement des PDF si nécessaire.
• Automatisation : Intégrer 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 de l’industrie en matière de sécurité des documents.

Sign

Le plugin 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 plugin prend en charge les signatures visibles et invisibles et fournit des options pour personnaliser la position de la signature, la raison, les coordonnées et plus encore.

Comment signer des documents PDF

Pour signer un document PDF en utilisant un fichier PFX, suivez ces étapes :

1. Initialisez 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// Créez un objet SignOptions pour définir les instructions
2var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
3// Ajoutez le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Définissez le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
7// Effectuez le processus
8PdfSecurity.Sign(options);

Comment utiliser un flux pour le fichier PFX

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

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

Comment appliquer des signatures invisibles

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

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

1var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
2options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
3options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
4// Configurez la signature invisible
5signOptions.Visible = false;
6// Effectuez le processus
7PdfSecurity.Sign(options);

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

Vous pouvez utiliser des options supplémentaires lors de l’ajout d’une signature à un fichier PFX comme Raison, Contact, Localisation, Numéro de page.

1. Initialisez 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 pour vos options.
4. Exécutez la méthode Sign pour appliquer la signature.

 1// Créez un objet SignOptions pour définir les instructions
 2var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
 3// Ajoutez le chemin du fichier d'entrée
 4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
 5// Définissez le chemin du fichier de sortie
 6options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
 7// Paramètres facultatifs
 8options.Reason = "ma Raison";
 9options.Contact = "mon Contact";
10options.Location = "ma Localisation";
11options.PageNumber = 3;
12// Effectuez le processus
13PdfSecurity.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 en utilisant la méthode AddInput.
3. Définissez le chemin du fichier de sortie en utilisant AddOutput.
4. Exécutez l’horodatage en utilisant la méthode Sign.

1// Créez un objet SignOptions pour définir les instructions
2var options = new SignOptions("path_to_your_pfx_file.pfx", "password_for_your_pfx_file");
3options.TimestampOptions = new TimestampOptions("server_url");
4// Ajoutez le chemin du fichier d'entrée
5options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
6// Définissez le chemin du fichier de sortie
7options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
8// Effectuez le processus
9PdfSecurity.Sign(options);

Comment utiliser l’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 nécessitent un nom d’utilisateur et un mot de passe.

1// Configurez les options d'horodatage avec authentification
2options.TimestampOptions = new TimestampOptions("timestamp_server_url", "username:password");

Caractéristiques clés :

• Signer numériquement les documents PDF : Sécurisez vos documents avec des signatures numériques visibles ou invisibles.
• Support PFX : Signez des fichiers PDF en utilisant un certificat PFX.
• Options personnalisables : Configurez les paramètres de signature comme la raison, la localisation et les coordonnées.
• Signatures visibles et invisibles : Choisissez si la signature est visible sur le document.
• Serveurs d’horodatage personnalisables : Utilisez des URL de serveur d’horodatage personnalisées et des identifiants d’authentification.

PDF Form Flattener

Le plugin Documentize PDF Form Flattener pour .NET est conçu pour convertir des 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, améliorant ainsi la sécurité de vos documents PDF. Il est particulièrement utile lorsque vous devez sécuriser des contrats, des accords ou tout document où les champs de formulaire 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 FormFlattenerOptions.
2. Ajoutez les fichiers d’entrée et de sortie aux options.
3. Appelez la méthode Process pour effectuer l’opération d’aplatissement.

1// Créer un objet FormFlattenerOptions pour définir les instructions
2var options = new FormFlattenerOptions();
3// Ajouter le chemin du fichier d'entrée
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Définir le chemin du fichier de sortie
6options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
7// Effectuer le processus
8FormFlattener.Process(options);

Comment obtenir tous les champs dans un PDF

Vous pouvez obtenir des informations sur le nombre de champs qu’un document contient.

1// Obtenir les noms des champs
2var fieldNames = FormFlattener.GetFieldNames("path_to_your_pdf_file.pdf");

Comment aplatir tout sauf le premier champ dans un PDF

Vous pouvez aplatir sélectivement seulement des champs de formulaire spécifiques en fonction de critères tels que la position ou le nom du champ.

 1// Obtenir les noms des champs
 2var fieldNames = FormFlattener.GetFieldNames("path_to_your_pdf_file.pdf");
 3// Créer un objet FormFlattenerOptions pour définir les instructions
 4var options = new FormFlattenerOptions();
 5options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
 6options.AddOutput(new FileDataSource("path_to_result_pdf_file.pdf"));
 7// Sauter 1 champ.
 8options.SkipFields.Add(fieldNames[0]);
 9// Effectuer le processus
10FormFlattener.Process(options);

Caractéristiques clés :

• Aplatir tous les champs de formulaire : Convertit des champs de formulaire interactifs en contenu statique non modifiable.
• Aplatir des champs sélectionnés : Aplatir facultativement des champs spécifiques dans un PDF tout en gardant d’autres modifiables.
• Aplatir obtenir les noms des champs : Obtenir les noms des champs dans un PDF.