how to combine two word documents into one programmatically c

Daniel Parker

3 min read

·

16-01-2025

1

0

Share

Combining Word documents programmatically offers significant advantages for automation and large-scale document processing. This article demonstrates how to merge two .docx files into a single document using C# and the DocumentFormat.OpenXml library. This method provides a robust and efficient solution compared to other approaches.

Setting Up Your Project

Before we begin, ensure you have the necessary NuGet package installed. In your C# project, navigate to NuGet Package Manager and install DocumentFormat.OpenXml. This library provides the tools to work directly with the Open XML structure of Word documents.

The C# Code: Merging Two Word Documents

The following C# code efficiently merges two .docx files:

using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;

public static void MergeWordDocuments(string doc1Path, string doc2Path, string outputPath)
{
    try
    {
        using (WordprocessingDocument doc1 = WordprocessingDocument.Open(doc1Path, true))
        using (WordprocessingDocument doc2 = WordprocessingDocument.Open(doc2Path, false))
        using (WordprocessingDocument mergedDoc = WordprocessingDocument.Create(outputPath, WordprocessingDocumentType.Document))
        {
            // Copy main document part from doc1
            MainDocumentPart mainPart = mergedDoc.AddMainDocumentPart();
            mainPart.Document = (Document)doc1.MainDocumentPart.Document.CloneNode(true);

            // Copy all other parts from doc1 (styles, images etc.)
            CopyParts(doc1, mergedDoc);


            // Append the content from doc2
            Body body = mainPart.Document.Body;
            Body doc2Body = doc2.MainDocumentPart.Document.Body;
            foreach (var element in doc2Body.ChildElements)
            {
                body.AppendChild(element.CloneNode(true));
            }


            mergedDoc.MainDocumentPart.Document.Save();
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine({{content}}quot;Error merging documents: {ex.Message}");
    }
}


// Helper function to copy parts from one document to another
private static void CopyParts(WordprocessingDocument source, WordprocessingDocument target)
{
    foreach (var part in source.MainDocumentPart.Parts)
    {
        target.MainDocumentPart.AddPart(part.OpenXmlPart, part.RelationshipId);
    }
}


// Example Usage
public static void Main(string[] args)
{
    string doc1Path = "path/to/document1.docx";
    string doc2Path = "path/to/document2.docx";
    string outputPath = "path/to/mergedDocument.docx";

    MergeWordDocuments(doc1Path, doc2Path, outputPath);
    Console.WriteLine("Documents merged successfully!");
}

Remember to replace "path/to/document1.docx", "path/to/document2.docx", and "path/to/mergedDocument.docx" with the actual paths to your files.

Explanation

1. Namespaces: The code starts by including the necessary namespaces from the DocumentFormat.OpenXml.Packaging and DocumentFormat.OpenXml.Wordprocessing libraries.

2. MergeWordDocuments Function: This function takes the paths of the two input documents and the output document as arguments. It uses using statements to ensure proper disposal of the WordprocessingDocument objects.

3. Opening Documents: The code opens both input documents and creates a new output document using WordprocessingDocument.Open and WordprocessingDocument.Create.

4. Copying Main Document Part: The main document part (containing the body text) from the first document is copied to the new document.

5. Copying Other Parts: The CopyParts helper function recursively copies all related parts (styles, images, etc.) from the first document to ensure that formatting and embedded elements are preserved.

6. Appending Second Document's Content: The content of the second document's body is appended to the body of the new document. The CloneNode(true) method is crucial for creating a deep copy of the XML elements, preserving all attributes and child nodes.

7. Saving the Merged Document: The merged document is saved to the specified output path.

8. Error Handling: A try-catch block handles potential exceptions during the merging process, providing informative error messages.

9. CopyParts Helper Function: This function efficiently iterates through all parts associated with the main document part and adds them to the new document. This ensures that styles, images, and other elements from the source document are correctly included in the merged document.

10. Example Usage: The Main function provides a simple example of how to use the MergeWordDocuments function.

Handling Errors and Exceptions

The try-catch block is essential. It catches potential exceptions, such as file not found errors or issues with document structure. Robust error handling makes your application more reliable.

This approach provides a complete and efficient solution for merging Word documents programmatically in C#. Remember to handle potential exceptions appropriately in a production environment. Always test thoroughly with various document types to ensure compatibility and robustness.