Les fichiers PDF (Portable Document Format) sont largement utilisés pour le partage et la présentation de documents, et il y a des moments où vous pouvez avoir 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, diviser les PDF peut être une tâche précieuse dans diverses situations.

Dans cet article, nous allons apprendre comment diviser des PDF en utilisant C#. C# est un langage polyvalent et puissant, et il existe plusieurs bibliothèques disponibles qui rendent relativement simple la manipulation des PDF. Nous explorerons les deux bibliothèques suivantes pour diviser les PDF en C#.

1. iText
2. IronPDF

Comment diviser un PDF en C# en utilisant iText

1. Commencez par installer la bibliothèque iText.
2. Créez un PdfReader à partir du fichier PDF d'entrée.
3. Utilisez un PdfDocument pour travailler avec le contenu du PDF.
4. Calculez le nombre de pages pour chaque fichier divisé.
5. Définissez les valeurs de plage de pages initiales.
6. Utilisez une boucle pour traiter chaque fichier divisé.
7. Créez un nouveau PdfDocument pour le fichier divisé actuel.
8. Copiez les pages du document original vers le nouveau.
9. Mettez à jour les valeurs de plage de pages pour la prochaine itération.
10. Enregistrez le PDF de sortie complété.
11. Répétez jusqu'à ce que tous les fichiers soient créés.
12. Continuez le processus pour le nombre spécifié de fichiers divisés.

IronPDF

IronPDF est une bibliothèque C# puissante conçue pour travailler avec des fichiers PDF. It provides features for creating, modifying, and extracting content from PDF documents. Les développeurs peuvent générer des PDFs à partir de zéro, éditer les PDFs existants, et les fusionner ou les diviser. De plus, IronPDF excelle dans la conversion de contenu HTML en format PDF, ce qui le rend utile pour générer des rapports ou de la documentation. Avec le support des signatures numériques, des fonctionnalités de sécurité et une sortie de haute qualité, IronPDF simplifie les tâches liées aux PDF dans les applications .NET.

iText

iText (iText) est une bibliothèque largement utilisée pour travailler avec des fichiers PDF dans le cadre .NET. Elle offre des fonctionnalités puissantes pour créer, modifier et extraire du contenu des documents PDF de manière programmatique. Les développeurs peuvent utiliser iText pour ajouter du texte, des images, des tableaux, et d'autres éléments graphiques aux PDFs. De plus, elle prend en charge l'assemblage de documents, les signatures numériques et la conformité aux normes d'archivage et d'accessibilité. Initialement une bibliothèque Java, iText a été porté à .NET et a 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 -> Gestionnaire de packages NuGet -> Console du gestionnaire de packages.

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

   PM > Install-Package IronPdf

Cela téléchargera et installera le package 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 directement le package à votre fichier de projet. Une autre option consiste à télécharger le package depuis le site officiel et à l'ajouter manuellement à votre projet. Chaque méthode offre un moyen simple d'intégrer IronPDF dans votre projet C# pour des fonctionnalités liées aux PDF.

Installer la bibliothèque iText

Pour installer iText en utilisant la Console du Gestionnaire de Packages dans Visual Studio, vous pouvez suivre ces étapes :

1. Dans Visual Studio, allez dans Outils -> Gestionnaire de packages NuGet -> Console du gestionnaire de packages.

2. Utilisez la commande suivante pour installer le package NuGet iText :

   Install-Package itext7

   SHELL

Cela téléchargera et installera le package iText avec ses dépendances dans votre projet. Une fois l'installation terminée, vous pouvez commencer à utiliser iText dans votre projet C# pour travailler avec des PDFs.

Diviser des documents PDF en C# en using IronPDF

Nous pouvons diviser un fichier PDF en plusieurs fichiers PDF avec IronPDF. Cela offre un moyen simple d'y parvenir. Le code suivant prendra le fichier PDF source en entrée et le divisera en plusieurs fichiers PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        string file = "input.pdf";
        // The folder to save the split PDFs
        string outputFolder = "output_split";
        int numberOfSplitFiles = 3; // Specify how many parts you want to split the PDF into
        // Call the SplitPdf method to split the PDF
        SplitPdfUsing IronPDF(file, outputFolder, numberOfSplitFiles);
    }

    static void SplitPdfUsing IronPDF(string inputPdfPath, string outputFolder, int numberOfSplitFiles)
    {
        // Load the input PDF
        PdfDocument sourceFile = PdfDocument.FromFile(inputPdfPath);
        
        // Initialize page range values
        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);

            // Generate the output file path
            string name = $@"{outputFolder}\SplitPDF_IronPDF_{i}.pdf";
            
            // Save the new split PDF
            newSplitPDF.SaveAs(name);

            // Update page range values for the next iteration
            firstPage = lastPage + 1;
            lastPage += totalPageInOneFile;
        }
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        string file = "input.pdf";
        // The folder to save the split PDFs
        string outputFolder = "output_split";
        int numberOfSplitFiles = 3; // Specify how many parts you want to split the PDF into
        // Call the SplitPdf method to split the PDF
        SplitPdfUsing IronPDF(file, outputFolder, numberOfSplitFiles);
    }

    static void SplitPdfUsing IronPDF(string inputPdfPath, string outputFolder, int numberOfSplitFiles)
    {
        // Load the input PDF
        PdfDocument sourceFile = PdfDocument.FromFile(inputPdfPath);
        
        // Initialize page range values
        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);

            // Generate the output file path
            string name = $@"{outputFolder}\SplitPDF_IronPDF_{i}.pdf";
            
            // Save the new split PDF
            newSplitPDF.SaveAs(name);

            // Update page range values for the next iteration
            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 en utilisant la bibliothèque IronPDF. La méthode SplitPdfUsing IronPDF est définie pour atteindre cette fonctionnalité.

Paramètres de 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 représentant le dossier de sortie où les fichiers PDF divisés seront enregistrés (par exemple, "output_split").
3. numberOfSplitFiles : Un entier indiquant en combien de fichiers PDF plus petits le PDF original sera divisé.

Processus de Division

À l'intérieur de la méthode SplitPdfUsing IronPDF :

1. Un objet PdfDocument nommé sourceFile est créé en chargeant le PDF à partir du inputPdfPath spécifié.
2. Deux variables entières, firstPage et lastPage, sont initialisées. Celles-ci représentent la plage de pages pour la division.
3. totalPageInOneFile est calculé en divisant le nombre total de pages du PDF source par le numberOfSplitFiles 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 (inclus) sont copiées du sourceFile à newSplitPDF.
7. Le fichier PDF plus petit résultant est enregistré avec un nom de fichier comme "SplitPDF_IronPDF_1.pdf" (pour le premier split) dans le dossier de sortie spécifié.
8. Les valeurs firstPage et lastPage sont mises à jour pour la prochaine itération.

Remarque

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 :

Diviser des PDFs en C# en utilisant iText

Maintenant, nous allons utiliser iText pour diviser notre document PDF en plusieurs fichiers PDF. Le code suivant prendra le fichier source en entrée et divisera ce document PDF en plusieurs fichiers plus petits.

using System;
using iText.Kernel.Pdf;

class Program
{
    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; // Specify how many parts you want to split the PDF into
        // 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))
            {
                // Calculate the number of pages for each split file
                int totalPageInOneFile = doc.GetNumberOfPages() / numberOfSplitFiles;
                int firstPage = 1;
                int lastPage = totalPageInOneFile;

                for (int i = 1; i <= numberOfSplitFiles; i++)
                {
                    // Generate the output file path
                    string filename = $@"{outputFolder}\SplitPDF_iTextSharp_{i}.pdf";

                    // Create a new document and attach a writer for the specified output file
                    using (PdfDocument pdfDocument = new PdfDocument(new PdfWriter(filename)))
                    {
                        // Copy pages from the original document to the new document
                        doc.CopyPagesTo(firstPage, lastPage, pdfDocument);
                    }

                    // Update page range values for the next iteration
                    firstPage = lastPage + 1;
                    lastPage += totalPageInOneFile;
                }
            }
        }
    }
}

using System;
using iText.Kernel.Pdf;

class Program
{
    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; // Specify how many parts you want to split the PDF into
        // 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))
            {
                // Calculate the number of pages for each split file
                int totalPageInOneFile = doc.GetNumberOfPages() / numberOfSplitFiles;
                int firstPage = 1;
                int lastPage = totalPageInOneFile;

                for (int i = 1; i <= numberOfSplitFiles; i++)
                {
                    // Generate the output file path
                    string filename = $@"{outputFolder}\SplitPDF_iTextSharp_{i}.pdf";

                    // Create a new document and attach a writer for the specified output file
                    using (PdfDocument pdfDocument = new PdfDocument(new PdfWriter(filename)))
                    {
                        // Copy pages from the original document to the new document
                        doc.CopyPagesTo(firstPage, lastPage, pdfDocument);
                    }

                    // Update page range values for the next iteration
                    firstPage = lastPage + 1;
                    lastPage += totalPageInOneFile;
                }
            }
        }
    }
}

Imports System
Imports iText.Kernel.Pdf

Friend Class Program
	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 ' Specify how many parts you want to split the PDF into
		' Call the SplitPdf method to split the PDF
		SplitPdfUsingiTextSharp(inputPath, outputPath, numberOfSplitFiles)
	End Sub

	Private 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)
				' Calculate the number of pages for each split file
'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

				For i As Integer = 1 To numberOfSplitFiles
					' Generate the output file path
					Dim filename As String = $"{outputFolder}\SplitPDF_iTextSharp_{i}.pdf"

					' Create a new document and attach a writer for the specified output file
					Using pdfDocument As New PdfDocument(New PdfWriter(filename))
						' Copy pages from the original document to the new document
						doc.CopyPagesTo(firstPage, lastPage, pdfDocument)
					End Using

					' Update page range values for the next iteration
					firstPage = lastPage + 1
					lastPage += totalPageInOneFile
				Next i
			End Using
		End Using
	End Sub
End Class

Imports System
Imports iText.Kernel.Pdf

Friend Class Program
	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 ' Specify how many parts you want to split the PDF into
		' Call the SplitPdf method to split the PDF
		SplitPdfUsingiTextSharp(inputPath, outputPath, numberOfSplitFiles)
	End Sub

	Private 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)
				' Calculate the number of pages for each split file
'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

				For i As Integer = 1 To numberOfSplitFiles
					' Generate the output file path
					Dim filename As String = $"{outputFolder}\SplitPDF_iTextSharp_{i}.pdf"

					' Create a new document and attach a writer for the specified output file
					Using pdfDocument As New PdfDocument(New PdfWriter(filename))
						' Copy pages from the original document to the new document
						doc.CopyPagesTo(firstPage, lastPage, pdfDocument)
					End Using

					' Update page range values for the next iteration
					firstPage = lastPage + 1
					lastPage += totalPageInOneFile
				Next i
			End Using
		End Using
	End Sub
End Class

Explication du code

Ce code montre comment diviser un fichier PDF volumineux en morceaux plus petits en utilisant iText. Chaque document PDF plus petit contiendra une partie du document original.

Diviser un PDF en utilisant iText

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

À l'intérieur de la méthode SplitPdfUsingiTextSharp :

1. Un objet PdfReader nommé reader est créé en chargeant le PDF à partir du 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 combien de pages chaque PDF plus petit devrait contenir.

Processus de Division

Une boucle itère de 1 à numberOfSplitFiles :

1. Un nouveau fichier PDF plus petit est créé avec un nom de fichier tel que "SplitPDF_iText_1.pdf" (pour la première division) dans le dossier de sortie spécifié.
2. À l'intérieur de ce nouveau document PDF (pdfDocument), des pages sont copiées à partir de l'original doc :
3. firstPage à lastPage (inclus) sont copiées.
4. Le PDF plus petit est enregistré.
5. Les valeurs firstPage et lastPage sont mises à jour pour la prochaine itération.

Remarque

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

Comparaison

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

1. Facilité d'utilisation :
   • iText : La méthode iText implique la création d'un PdfReader, PdfDocument, et PdfWriter. Elle calcule les plages de pages et copie les pages vers un nouveau document. Cette approche nécessite de comprendre l'API iText.
   • IronPDF : La méthode IronPDF implique de créer un PdfDocument à partir du fichier source, de copier les pages, et de les enregistrer dans un nouveau fichier. Elle a une API plus simple.
2. Lisibilité du code :
   • iText : 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éthodes.
3. Performance :
   • iText : La performance peut être affectée 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 une meilleure performance grâce à une copie de pages efficace.
4. Utilisation de la mémoire :
   • iText : La création de plusieurs instances de PdfDocument consommera plus de mémoire.
   • IronPDF : La méthode est plus économe en mémoire grâce à son approche simplifiée.

Conclusion

En conclusion, iText et IronPDF offrent des solutions robustes pour diviser des fichiers PDF en C#, chacune avec ses propres avantages. IronPDF se distingue par sa simplicité, sa lisibilité, et potentiellement une meilleure performance grâce à une approche plus directe.

Les développeurs cherchant un équilibre entre la polyvalence et la facilité d'utilisation peuvent trouver IronPDF un choix convaincant. De plus, IronPDF offre un essai gratuit. En fin de compte, le choix entre iText et IronPDF dépend des exigences du projet individuel et du style de développement préféré.