A Comparison of Splitting PDF in C# Between iTextSharp and IronPDF

PDF (Portable Document Format) files are widely used for sharing and presenting documents, and there are times when you may need to split a PDF into multiple files. Whether you want to extract specific pages, divide a large document into smaller sections, or create individual files for each chapter, splitting PDFs can be a valuable task in various scenarios.

In this article, we'll learn how to split PDFs using C#. C# is a versatile and powerful language, and there are several libraries available that make it relatively straightforward to manipulate PDFs. We will explore the following two Libraries for Splitting PDF in C#.

1. iTextSharp
2. IronPDF

How to Split PDF in C# Using ITextSharp

1. First Install the iText7 Library
2. Create a PdfReader from the input PDF file.
3. Use a PdfDocument to work with the PDF content.
4. Calculate the number of pages for each split file.
5. Set initial page range values.
6. Use a loop to process each split file.
7. Create a new PdfDocument for the current split file.
8. Copy pages from the original document to the new one.
9. Update page range values for the next iteration.
10. Save the completed output PDF.
11. Repeat Until All Files Created:
12. Continue the process for the specified number of split files.

IronPDF

IronPDF is a powerful C# library designed for working with PDF files. It provides features for creating, modifying, and extracting content from PDF documents. Developers can generate PDFs from scratch, edit existing PDFs, and merge or split them. Additionally, IronPDF excels at converting HTML content to PDF format, making it useful for generating reports or documentation. With support for digital signatures, security features, and high-quality output, IronPDF simplifies PDF-related tasks in .NET applications.

iTextSharp

iTextSharp (iText 7) is a widely used library for working with PDF files in the .NET framework. It provides powerful features for creating, modifying, and extracting content from PDF documents programmatically. Developers can use iTextSharp to add text, images, tables, and other graphical elements to PDFs. Additionally, it supports document assembly, digital signatures, and compliance with archival and accessibility standards. Originally a Java library, iTextSharp was ported to .NET and has an active community of developers and users.

Installing the IronPDF Library

To install the IronPDF NuGet package using Package Manager Console in Visual Studio, follow these steps:

1. In Visual Studio, go to Tools -> NuGet Package Manager -> Package Manager Console.

2. Use the following command to install the IronPDF NuGet package:

   Install-Package IronPdf

This will download and install the IronPDF package along with its dependencies into your project. Once the installation is complete, you can start using IronPDF in your C# project for PDF-related tasks.

Alternatively, you can install IronPDF using the NuGet Package Manager in Visual Studio, or add the package directly to your project file. Another option is downloading the package from the official website and manually adding it to your project. Each method provides a straightforward way to integrate IronPDF into your C# project for PDF-related functionalities.

Installing the iTextSharp Library

To install iTextSharp using Package Manager Console in Visual Studio, you can follow these steps:

1. In Visual Studio, go to Tools -> NuGet Package Manager -> Package Manager Console.

2. Use the following command to install the iTextSharp NuGet package:

   Install-Package itext7

This will download and install the iTextSharp package along with its dependencies into your project. Once the installation is complete, you can start using iTextSharp in your C# project for working with PDFs.

Split PDF Documents in C# Using IronPDF

We can split a PDF file into multiple PDF files Using IronPDF. It provides a simple way to achieve this. The following code will take the source PDF file as input and split it into multiple PDF files.

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; } }

Code Explanation

The purpose of this code is to split a given PDF file into multiple smaller PDF files using the IronPDF library. The SplitPdfUsingIronPDF method is defined to achieve this functionality.

Method Parameters

1. inputPdfPath: A string representing the path to the input PDF file (e.g., "input.pdf").
2. outputFolder: A string representing the output folder where the split PDF files will be saved (e.g., "output_split").
3. NumberOfSplitFiles: An integer indicating how many smaller PDF files the original PDF will be split into.

Splitting Process

Inside the SplitPdfUsingIronPDF method:

1. A PdfDocument object named sourceFile is created by loading the PDF from the specified inputPdfPath.
2. Two integer variables, firstPage and lastPage, are initialized. These represent the page range for splitting.
3. totalPageInOneFile is calculated by dividing the total page count of the source PDF by the specified NumberOfSplitFiles.
4. A loop iterates from 1 to NumberOfSplitFiles:
5. A new PdfDocument object named newSplitPDF is created.
6. Pages from firstPage to lastPage (inclusive) are copied from the sourceFile to newSplitPDF.
7. The resulting smaller PDF is saved with a filename like "SplitPDF_IronPDF_1.pdf" (for the first split) in the specified output folder.
8. The firstPage and lastPage values are updated for the next iteration.

Note

You should replace "input.pdf" with the actual path to your input PDF file. Ensure that the IronPDF library is properly installed and referenced in your project.

The output files are created as:

Split PDFs in C# Using iTextSharp

Now, we will use iTextSharp to split our PDF document into multiple PDF files. The following code will take the source file as input and split that PDF document into multiple smaller files.

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

Code Explanation

This above code demonstrates how to split a large PDF file into smaller chunks using iTextSharp. Each smaller PDF document will contain a portion of the original document.

Splitting PDF Using iTextSharp

1. The main functionality is encapsulated in the SplitPdfUsingiTextSharp method.
2. The above method takes three parameters: inputPdfPath, outputFolder, and NumberOfSplitFiles.

Using PdfReader and PdfDocument

Inside the SplitPdfUsingiTextSharp method:

1. A PdfReader object named Reader is created by loading the PDF from the specified inputPdfPath.
2. A PdfDocument object named DOC is initialized using the Reader.
3. The total number of pages in the source PDF is divided by NumberOfSplitFiles to determine how many pages each smaller PDF should contain.

Splitting Process

A loop iterates from 1 to NumberOfSplitFiles:

1. A new smaller PDF file is created with a filename like "SplitPDF_iTextSharp_1.pdf" (for the first split) in the specified output folder.
2. Inside this new PDF document (pdfDocument), pages are copied from the original doc:
3. firstPage to lastPage (inclusive) are copied.
4. The smaller PDF is saved.
5. The firstPage and lastPage values are updated for the next iteration.

Note

Ensure that the iTextSharp library is properly installed and referenced in your project. Replace "input.pdf" with the actual path to your input PDF file.

Comparison

To compare the two split methods using iTextSharp and IronPDF, let's evaluate them based on several factors:

1. Ease of Use:
   • iTextSharp: The iTextSharp method involves creating a PdfReader, PdfDocument, and PdfWriter. It calculates page ranges and copies pages to a new document. This approach requires understanding the iTextSharp API.
   • IronPDF: The IronPDF method involves creating a PdfDocument from the source file, copying pages, and saving them to a new file. It has a more straightforward API.
2. Code Readability:
   • iTextSharp: The code involves more steps, making it slightly longer and potentially more complex to read.
   • IronPDF: The code is concise and more readable due to fewer steps and method calls.
3. Performance:
   • iTextSharp: Performance may be affected by the repeated creation and disposal of PdfDocument instances.
   • IronPDF: The method involves fewer steps and offers better performance due to efficient page copying.
4. Memory Usage:
   • iTextSharp: Creating multiple PdfDocument instances will consume more memory.
   • IronPDF: The method is more memory-efficient due to its simplified approach.

Conclusion

In conclusion, both iTextSharp and IronPDF offer robust solutions for splitting PDF files in C#, each with its own set of advantages. IronPDF stands out for its simplicity, readability, and potentially better performance due to a more straightforward approach.

Developers seeking a balance between versatility and ease of use may find IronPDF to be a compelling choice. Additionally, IronPDF offers a free trial. Ultimately, the selection between iTextSharp and IronPDF depends on individual project requirements and the preferred development style.