How to Merge PDF Files in .NET

How Do You Install IronPDF for .NET Merge PDF?

Getting started with IronPDF requires just a simple NuGet package installation. Open your Package Manager Console in Visual Studio and run:

Install-Package IronPdf

Once installed, add the IronPDF namespace to your C# file:

using IronPdf;

using IronPdf;

That's all the setup needed. IronPDF handles all the complex PDF manipulation behind the scenes, letting you focus on your application logic. With the library installed, you're ready to start merging both existing and new PDF documents immediately. Note that this process is compatible with various operating systems, including Linux via .NET Core. For detailed installation guidance, visit the IronPDF installation documentation.

How to Merge Two PDF Documents?

The most basic merging scenario involves combining two existing or new PDFDocument objects. Here's how to accomplish this task:

using IronPdf;
class Program
{
    static void Main()
    {
        // Load the PDF documents
        var pdf1 = PdfDocument.FromFile("Invoice1.pdf");
        var pdf2 = PdfDocument.FromFile("Invoice2.pdf");
        // Merge the documents
    var merged = PdfDocument.Merge(pdf1, pdf2);
    // Save the merged document
    merged.SaveAs("Merged.pdf"); 
    }
}

using IronPdf;
class Program
{
    static void Main()
    {
        // Load the PDF documents
        var pdf1 = PdfDocument.FromFile("Invoice1.pdf");
        var pdf2 = PdfDocument.FromFile("Invoice2.pdf");
        // Merge the documents
    var merged = PdfDocument.Merge(pdf1, pdf2);
    // Save the merged document
    merged.SaveAs("Merged.pdf"); 
    }
}

This code demonstrates the simplicity of merging PDFs with IronPDF. The PdfDocument.FromFile() method loads existing PDF files into memory. These loaded documents become PdfDocument objects that can be manipulated programmatically.

The Merge() method takes two or more PdfDocument objects and combines them into a single PDF file. The PDF pages from the second document are appended after the pages of the first document, maintaining the original order and formatting of each page. Learn more about the Merge method in the API documentation.

Finally, SaveAs() writes the merged document to disk. The resulting PDF contains all pages from both source documents in sequence, ready for distribution or further processing.

How to Merge Multiple PDF Files?

Real-world applications often need to merge PDF files beyond just two documents. As we saw in the previous example, IronPDF can easily handle the merging of PDF files in just a couple lines of code. Now, we'll look at how IronPDF can handle this scenario elegantly using a List collection:

using IronPdf;
using System.Collections.Generic;
using System.IO;
class Program
{
    static void Main()
    {
        // Create a list to store PDF documents
        var files = new List<PdfDocument>();
        // Get all PDF files from a directory
        string[] fileNames = Directory.GetFiles(@"C:\Reports\", "*.pdf");
        // Load each PDF file
        foreach (var fileName in fileNames)
        {
            files.Add(PdfDocument.FromFile(fileName));
        }
        // Merge all PDFs into one
        var merged = PdfDocument.Merge(pdfs);
        // Save the combined document
        merged.SaveAs("CombinedReports.pdf");
    }
}

using IronPdf;
using System.Collections.Generic;
using System.IO;
class Program
{
    static void Main()
    {
        // Create a list to store PDF documents
        var files = new List<PdfDocument>();
        // Get all PDF files from a directory
        string[] fileNames = Directory.GetFiles(@"C:\Reports\", "*.pdf");
        // Load each PDF file
        foreach (var fileName in fileNames)
        {
            files.Add(PdfDocument.FromFile(fileName));
        }
        // Merge all PDFs into one
        var merged = PdfDocument.Merge(pdfs);
        // Save the combined document
        merged.SaveAs("CombinedReports.pdf");
    }
}

This sample code showcases a more dynamic approach to PDF merging. The code uses Directory.GetFiles() to automatically discover all PDF files in a specified folder, eliminating the need to hardcode individual file names. According to Microsoft's documentation on file operations, this method efficiently retrieves file paths matching your criteria.

Each discovered PDF file is loaded as a PdfDocument and added to a List collection. This approach scales efficiently whether you're merging three files or three hundred. The Merge() method accepts the entire list, processing all source documents in a single operation to create one new document. You can also make use of the int data type to track the index of each file as it's processed, if you wanted to.

The foreach loop provides a clean way to iterate through multiple PDF files, and you could easily add filtering logic here to select specific destination document files based on naming patterns, dates, or other criteria. This pattern works well for batch processing scenarios like monthly report compilation or document archival processes. For more advanced page manipulation options, explore the IronPDF page management features.

지금 바로 IronPDF으로 시작하세요.

무료로 시작하세요

How to Merge PDF Files from Different Sources?

Sometimes you need to combine PDF files from various sources - perhaps merging dynamically generated content with existing templates. IronPDF handles this seamlessly:

using IronPdf;
using System;
using System.IO;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // Create a PDF from HTML
        string html = @"<h1>Cover Page</h1>
                       <p>Example PDF From Multiple Sources</p>
                       <div style='page-break-after: always;'></div>";
        var coverPage = renderer.RenderHtmlAsPdf(html);
        // Load an existing PDF report
        var pdf = PdfDocument.FromFile(@"invoice.pdf");
        // Create a summary from URL
        var summary = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/Main_Page");
        // Merge all three sources
        var finalDocument = PdfDocument.Merge(new[] { coverPage, pdf, summary });
        // Save the complete document
        finalDocument.SaveAs("MultipleSources.pdf");
    }
}

using IronPdf;
using System;
using System.IO;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // Create a PDF from HTML
        string html = @"<h1>Cover Page</h1>
                       <p>Example PDF From Multiple Sources</p>
                       <div style='page-break-after: always;'></div>";
        var coverPage = renderer.RenderHtmlAsPdf(html);
        // Load an existing PDF report
        var pdf = PdfDocument.FromFile(@"invoice.pdf");
        // Create a summary from URL
        var summary = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/Main_Page");
        // Merge all three sources
        var finalDocument = PdfDocument.Merge(new[] { coverPage, pdf, summary });
        // Save the complete document
        finalDocument.SaveAs("MultipleSources.pdf");
    }
}

This advanced example demonstrates IronPDF's versatility in handling different PDF sources. The ChromePdfRenderer class enables HTML to PDF conversion, perfect for generating dynamic cover pages or formatted content from your application data. The renderer supports modern web standards as outlined in W3C specifications.

The RenderHtmlAsPdf() method converts HTML new strings directly to PDF, supporting full CSS styling and JavaScript. The length of the HTML string does not affect the conversion quality. The RenderUrlAsPdf() method fetches and converts web content, useful for incorporating live data or external resources. When dealing with web sources, an internal reader manages the stream data. You can learn more about these rendering options in the HTML to PDF tutorial.

By combining these rendering methods with existing PDF documents, you can create sophisticated document workflows. This approach works excellently for scenarios like adding branded cover pages to reports, appending legal disclaimers to contracts, or combining user-generated content with templates. The instance of the merged document maintains all formatting from each source file while creating a cohesive single PDF.

Conclusion

IronPDF transforms the complex task of merging PDF files in .NET into a straightforward process requiring minimal code. From simple two-file combinations to sophisticated multi-source document assembly, the library handles the technical complexity while providing an intuitive API. Whether you're working with a single file or processing large numbers of source documents, IronPDF maintains the integrity of your destination document throughout the merge process.

The examples in this tutorial demonstrate how easily you can integrate PDF merging capabilities into your .NET applications. Whether you're building document management systems, automating report generation, or processing user uploads, IronPDF provides the tools you need to combine PDF files efficiently and utilize various input sources.

Ready to implement PDF merging in your project? Start with a free trial that best fit your needs. Visit the comprehensive documentation for more advanced features like adding watermarks, applying security, splitting PDF documents, and troubleshooting tips for better exception handling.