Comparaison entre iTextSharp et IronPDF pour la division de PDF en C#

Les fichiers PDF (Portable Document Format) sont largement utilisés pour partager et présenter des documents, et il peut arriver que vous ayez besoin de diviser un PDF en plusieurs fichiers. Que vous souhaitiez extraire des pages spécifiques, diviser un document volumineux en sections plus petites ou créer des fichiers individuels pour chaque chapitre, la division des PDF peut s'avérer une tâche précieuse dans différents scénarios.

Dans cet article, nous allons apprendre à diviser des PDF à l'aide de C#. C# est un langage polyvalent et puissant, et il existe plusieurs bibliothèques qui rendent la manipulation des PDF relativement simple. Nous allons explorer les deux bibliothèques suivantes pour diviser les PDF en C#.

1. iTextSharp

2. IronPDF

Comment diviser un PDF en C# ; en utilisant ITextSharp

1. Installez d'abord la bibliothèque iText7

2. Créer un PdfReader à partir du fichier PDF d'entrée.

3. Utilisez un PdfDocument pour travailler avec le contenu du PDF.

4. Calculer le nombre de pages pour chaque fichier fractionné.

5. Définir les valeurs initiales de la plage de pages.

6. Utilisez une boucle pour traiter chaque fichier fractionné.

7. Crée un nouveau document Pdf pour le fichier fractionné actuel.

8. Copier les pages du document original dans le nouveau document.

9. Mettre à jour les valeurs de la plage de pages pour la prochaine itération.

10. Enregistrez le fichier PDF terminé.

11. Répéter l'opération jusqu'à ce que tous les fichiers soient créés :

12. Poursuivre le processus pour le nombre spécifié de fichiers fractionnés.

IronPDF

IronPDF est une puissante bibliothèque C# conçue pour travailler avec des fichiers PDF. Il offre des fonctionnalités pour créer, modifier et extraire du contenu à partir de documents PDF. Les développeurs peuvent créer des PDF à partir de zéro, éditer des PDF existants et fusionner ou diviser ceux-ci. En outre, IronPDF excelle dans la conversion de contenu HTML au format PDF, ce qui le rend utile pour générer des rapports ou de la documentation. Grâce à la prise en charge des signatures numériques, des fonctions de sécurité et des résultats de haute qualité, IronPDF simplifie les tâches liées aux PDF dans les applications .NET.

iTextSharp

iTextSharp (iText 7) est une bibliothèque largement utilisée pour travailler avec des fichiers PDF dans le framework .NET. Il offre de puissantes fonctionnalités pour créer, modifier et extraire le contenu des documents PDF de manière programmatique. Les développeurs peuvent utiliser iTextSharp pour ajouter du texte, des images, des tableaux et d'autres éléments graphiques aux PDF. En outre, il prend en charge l'assemblage des documents, les signatures numériques et la conformité aux normes d'archivage et d'accessibilité. Bibliothèque Java à l'origine, iTextSharp a été porté sur .NET et dispose d'une communauté active de développeurs et d'utilisateurs.

Installation de la bibliothèque IronPDF

Pour installer le package NuGet IronPDF en utilisant la Console du Gestionnaire de Packages dans Visual Studio, suivez ces étapes :

1. Dans Visual Studio, allez dans Outils -> NuGet Package Manager -> Console du gestionnaire de paquets.

2. Utilisez la commande suivante pour installer le paquet NuGet IronPDF :

    :ProductInstall

Ceci téléchargera et installera le paquetage IronPDF ainsi que ses dépendances dans votre projet. Une fois l'installation terminée, vous pouvez commencer à utiliser IronPDF dans votre projet C# pour les tâches liées aux PDF.

Alternativement, vous pouvez installer IronPDF en utilisant le gestionnaire de packages NuGet dans Visual Studio, ou ajouter le package directement à votre fichier de projet. Une autre option est de télécharger le package depuis le site officiel et de l'ajouter manuellement à votre projet. Chaque méthode offre un moyen simple d'intégrer IronPDF dans votre projet C# pour les fonctionnalités liées aux PDF.

Installation de la bibliothèque iTextSharp

Pour installer iTextSharp en utilisant la console du gestionnaire de packages dans Visual Studio, vous pouvez suivre ces étapes :

1. Dans Visual Studio, allez dans Outils -> NuGet Package Manager -> Console du gestionnaire de paquets.

2. Utilisez la commande suivante pour installer le paquetage NuGet iTextSharp :

    Install-Package itext7

Ceci téléchargera et installera le paquetage iTextSharp ainsi que ses dépendances dans votre projet. Une fois l'installation terminée, vous pouvez commencer à utiliser iTextSharp dans votre projet C# pour travailler avec des PDF.

Diviser des documents PDF en C# ; en utilisant IronPDF

Nous pouvons diviser un fichier PDF en plusieurs fichiers PDF à l'aide d'IronPDF. Il offre un moyen simple d'y parvenir. Le code suivant prend le fichier PDF source en entrée et le divise en plusieurs fichiers PDF.

static void Main(string [] args)
 {
    string file = "input.pdf"'
    // Call the SplitPdf method to split the PDF
    SplitPdfUsingIronPDF(file, "output_split", NumberOfSplitFiles);
 } 
static void SplitPdfUsingIronPDF(string inputPdfPath, string outputFolder, int NumberOfSplitFiles)
 {
     PdfDocument sourceFile = PdfDocument.FromFile(inputPdfPath);
     int firstPage = 1;
     int lastPage = 2;
     int totalPageInOneFile = sourceFile.PageCount / NumberOfSplitFiles;
     for (int i = 1; i <= NumberOfSplitFiles; i++)
     {
        // Copy multiple pages into a new document
        PdfDocument newSplitPDF = sourceFile.CopyPages(firstPage,lastPage);
        string name = $@"{outputFolder}\SplitPDF_IronPDF_{i}.pdf";
        newSplitPDF.SaveAs(name);
        firstPage = lastPage + 1;
        lastPage += totalPageInOneFile;
     }
 }

static void Main(string [] args)
 {
    string file = "input.pdf"'
    // Call the SplitPdf method to split the PDF
    SplitPdfUsingIronPDF(file, "output_split", NumberOfSplitFiles);
 } 
static void SplitPdfUsingIronPDF(string inputPdfPath, string outputFolder, int NumberOfSplitFiles)
 {
     PdfDocument sourceFile = PdfDocument.FromFile(inputPdfPath);
     int firstPage = 1;
     int lastPage = 2;
     int totalPageInOneFile = sourceFile.PageCount / NumberOfSplitFiles;
     for (int i = 1; i <= NumberOfSplitFiles; i++)
     {
        // Copy multiple pages into a new document
        PdfDocument newSplitPDF = sourceFile.CopyPages(firstPage,lastPage);
        string name = $@"{outputFolder}\SplitPDF_IronPDF_{i}.pdf";
        newSplitPDF.SaveAs(name);
        firstPage = lastPage + 1;
        lastPage += totalPageInOneFile;
     }
 }

Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'	string file = "input.pdf"' SplitPdfUsingIronPDF(file, "output_split", NumberOfSplitFiles); } static void SplitPdfUsingIronPDF(string inputPdfPath, string outputFolder, int NumberOfSplitFiles) { PdfDocument sourceFile = PdfDocument.FromFile(inputPdfPath); int firstPage = 1; int lastPage = 2; int totalPageInOneFile = sourceFile.PageCount / NumberOfSplitFiles; for(int i = 1; i <= NumberOfSplitFiles; i++) { PdfDocument newSplitPDF = sourceFile.CopyPages(firstPage,lastPage); string name = string.Format("{0}\SplitPDF_IronPDF_{1}.pdf", outputFolder, i); newSplitPDF.SaveAs(name); firstPage = lastPage + 1; lastPage += totalPageInOneFile; } }

Explication du code

L'objectif de ce code est de diviser un fichier PDF donné en plusieurs fichiers PDF plus petits à l'aide de la bibliothèque IronPDF. La méthode SplitPdfUsingIronPDF est définie pour réaliser cette fonctionnalité.

Paramètres de la méthode

1. inputPdfPath : Une chaîne représentant le chemin vers le fichier PDF d'entrée (par exemple, "input.pdf").

2. outputFolder : Une chaîne de caractères représentant le dossier de sortie où les fichiers PDF fractionnés seront enregistrés (par exemple, "output_split").

3. NumberOfSplitFiles : Un nombre entier indiquant le nombre de fichiers PDF plus petits dans lesquels le PDF original sera divisé.

Processus de fractionnement

Dans la méthode SplitPdfUsingIronPDF :

1. Un objet PdfDocument nommé sourceFile est créé en chargeant le PDF à partir du chemin d'accès inputPdfPath spécifié.

2. Deux variables entières, firstPage et lastPage, sont initialisées. Ils représentent la plage de pages pour le fractionnement.

3. le nombre total de pages dans un fichier est calculé en divisant le nombre total de pages du PDF source par le nombre de fichiers fractionnés spécifié.

4. Une boucle itère de 1 à NumberOfSplitFiles :

5. Un nouvel objet PdfDocument nommé newSplitPDF est créé.

6. Les pages de firstPage à lastPage (incluses) sont copiées du sourceFile vers le newSplitPDF.

7. Le PDF réduit résultant est enregistré avec un nom de fichier tel que "SplitPDF_IronPDF_1.pdf" (pour la première division) dans le dossier de sortie spécifié.

8. Les valeurs firstPage et lastPage sont mises à jour pour l'itération suivante.

Note

Vous devez remplacer "input.pdf" par le chemin réel de votre fichier PDF d'entrée. Assurez-vous que la bibliothèque IronPDF est correctement installée et référencée dans votre projet.

Les fichiers de sortie sont créés comme suit :

Diviser des PDF en C# ; Utiliser iTextSharp

Nous allons maintenant utiliser iTextSharp pour diviser notre document PDF en plusieurs fichiers PDF. Le code suivant prend le fichier source en entrée et divise le document PDF en plusieurs fichiers plus petits.

static void Main(string [] args)
 {
     string inputPath = "input.pdf";
     // Output PDF files path (prefix for the generated files)
     string outputPath = "output_split";
     int NumberOfSplitFiles = 3;
     // Call the SplitPdf method to split the PDF
     SplitPdfUsingiTextSharp(inputPath, outputPath, NumberOfSplitFiles);
 } 
static void SplitPdfUsingiTextSharp(string inputPdfPath, string outputFolder, int NumberOfSplitFiles)
 {
     using (PdfReader Reader = new PdfReader(inputPdfPath))
     {
         using (PdfDocument doc = new PdfDocument(Reader))
         {
             int totalPageInOneFile = doc.GetNumberOfPages() / NumberOfSplitFiles;
             int firstPage = 1;
             int lastPage = totalPageInOneFile; //  int pagenumber
             for (int i = 1; i <= NumberOfSplitFiles; i++)
             {
                 string filename = $@"{outputFolder}\SplitPDF_iTextSharp_{i}.pdf";
                 using (PdfDocument pdfDocument = new PdfDocument(new PdfWriter(filename))) // create output file
                 {
                     //pdfDocument.get
                     doc.CopyPagesTo(firstPage, lastPage, pdfDocument);
                 }
                 firstPage = lastPage + 1;
                 lastPage += totalPageInOneFile;
             }
         }
     }
 }

static void Main(string [] args)
 {
     string inputPath = "input.pdf";
     // Output PDF files path (prefix for the generated files)
     string outputPath = "output_split";
     int NumberOfSplitFiles = 3;
     // Call the SplitPdf method to split the PDF
     SplitPdfUsingiTextSharp(inputPath, outputPath, NumberOfSplitFiles);
 } 
static void SplitPdfUsingiTextSharp(string inputPdfPath, string outputFolder, int NumberOfSplitFiles)
 {
     using (PdfReader Reader = new PdfReader(inputPdfPath))
     {
         using (PdfDocument doc = new PdfDocument(Reader))
         {
             int totalPageInOneFile = doc.GetNumberOfPages() / NumberOfSplitFiles;
             int firstPage = 1;
             int lastPage = totalPageInOneFile; //  int pagenumber
             for (int i = 1; i <= NumberOfSplitFiles; i++)
             {
                 string filename = $@"{outputFolder}\SplitPDF_iTextSharp_{i}.pdf";
                 using (PdfDocument pdfDocument = new PdfDocument(new PdfWriter(filename))) // create output file
                 {
                     //pdfDocument.get
                     doc.CopyPagesTo(firstPage, lastPage, pdfDocument);
                 }
                 firstPage = lastPage + 1;
                 lastPage += totalPageInOneFile;
             }
         }
     }
 }

Shared Sub Main(ByVal args() As String)
	 Dim inputPath As String = "input.pdf"
	 ' Output PDF files path (prefix for the generated files)
	 Dim outputPath As String = "output_split"
	 Dim NumberOfSplitFiles As Integer = 3
	 ' Call the SplitPdf method to split the PDF
	 SplitPdfUsingiTextSharp(inputPath, outputPath, NumberOfSplitFiles)
End Sub
Shared Sub SplitPdfUsingiTextSharp(ByVal inputPdfPath As String, ByVal outputFolder As String, ByVal NumberOfSplitFiles As Integer)
	 Using Reader As New PdfReader(inputPdfPath)
		 Using doc As New PdfDocument(Reader)
'INSTANT VB WARNING: Instant VB cannot determine whether both operands of this division are integer types - if they are then you should use the VB integer division operator:
			 Dim totalPageInOneFile As Integer = doc.GetNumberOfPages() / NumberOfSplitFiles
			 Dim firstPage As Integer = 1
			 Dim lastPage As Integer = totalPageInOneFile '  int pagenumber
			 For i As Integer = 1 To NumberOfSplitFiles
				 Dim filename As String = $"{outputFolder}\SplitPDF_iTextSharp_{i}.pdf"
				 Using pdfDocument As New PdfDocument(New PdfWriter(filename)) ' create output file
					 'pdfDocument.get
					 doc.CopyPagesTo(firstPage, lastPage, pdfDocument)
				 End Using
				 firstPage = lastPage + 1
				 lastPage += totalPageInOneFile
			 Next i
		 End Using
	 End Using
End Sub

Explication du code

Le code ci-dessus montre comment diviser un gros fichier PDF en petits morceaux à l'aide d'iTextSharp. Chaque document PDF plus petit contiendra une partie du document original.

Fractionner un PDF à l'aide d'iTextSharp

1. La fonctionnalité principale est encapsulée dans la méthode SplitPdfUsingiTextSharp.

2. La méthode ci-dessus prend trois paramètres : inputPdfPath, outputFolder et NumberOfSplitFiles.

Utilisation de PdfReader et PdfDocument

Dans la méthode SplitPdfUsingiTextSharp :

1. Un objet PdfReader nommé Reader est créé en chargeant le PDF à partir de l'inputPdfPath spécifié.

2. Un objet PdfDocument nommé DOC est initialisé à l'aide du Reader.

3. Le nombre total de pages du PDF source est divisé par NumberOfSplitFiles pour déterminer le nombre de pages que chaque PDF plus petit doit contenir.

Processus de fractionnement

Une boucle itère de 1 à NumberOfSplitFiles :

1. Un nouveau fichier PDF plus petit est créé avec un nom de fichier comme "SplitPDF_iTextSharp_1.pdf" (pour la première division) dans le dossier de sortie spécifié.

2. Dans ce nouveau document PDF (pdfDocument), les pages sont copiées à partir du document original :

3. La première page à la dernière page (incluses) sont copiées.

4. Le PDF réduit est enregistré.

5. Les valeurs firstPage et lastPage sont mises à jour pour l'itération suivante.

Note

Assurez-vous que la bibliothèque iTextSharp est correctement installée et référencée dans votre projet. Remplacez "input.pdf" par le chemin d'accès à votre fichier PDF d'entrée.

Comparaison

Pour comparer les deux méthodes de fractionnement utilisant iTextSharp et IronPDF, évaluons-les sur la base de plusieurs facteurs :

1. Facilité d'utilisation :

   • iTextSharp : La méthode iTextSharp consiste à créer un PdfReader, un PdfDocument et un PdfWriter. Il calcule les intervalles de pages et copie les pages dans un nouveau document. Cette approche nécessite de comprendre l'API iTextSharp.

   • IronPDF : La méthode IronPDF consiste à créer un PdfDocument à partir du fichier source, à copier les pages et à les enregistrer dans un nouveau fichier. Elle possède une API plus simple.

2. Lisibilité du code :

   • iTextSharp : Le code implique plus d'étapes, ce qui le rend légèrement plus long et potentiellement plus complexe à lire.

   • IronPDF : Le code est concis et plus lisible en raison de moins d'étapes et d'appels de méthode.

3. Performance :

   • iTextSharp : Les performances peuvent être affectées par la création et la suppression répétées d'instances de PdfDocument.

   • IronPDF : La méthode implique moins d'étapes et offre de meilleures performances grâce à une copie de page efficace.

4. Utilisation de la mémoire :

   • iTextSharp : Créer plusieurs instances de PdfDocument consommera plus de mémoire.

   • IronPDF : La méthode est plus efficace en mémoire grâce à son approche simplifiée.

Conclusion

En conclusion, iTextSharp et IronPDF offrent tous deux des solutions robustes pour diviser les fichiers PDF en C#, chacun avec ses propres avantages. IronPDF se distingue par sa simplicité, sa lisibilité et ses performances potentiellement meilleures grâce à une approche plus directe.

Les développeurs recherchant un équilibre entre polyvalence et facilité d'utilisation peuvent trouver IronPDF comme un choix convaincant. De plus, IronPDF propose un essai gratuit. En fin de compte, le choix entre iTextSharp et IronPDF dépend des exigences de chaque projet et du style de développement privilégié.