Merging Word Documents with C#

• Download source - 22.4 Kb

Introduction

In my current project, the customer wants a set of features that will allow the administrator to publish a document in a website, let users work in that document (either changing it or adding comments) and submit the modified version back to the site. Then, the administrator would be able to see a summarized document with the changes introduced by all the users, allowing him to approve or reject them in a change-by-change basis.

Although I saw it quite difficult at first glance, digging deeper into the documentation, I found that besides the "track changes" feature in Word is also possible to merge several documents into a final one, so that all changes will be available in a single document. Of course, such feature could be used by means of VBA automation; hence, it's also available in .NET framework via COM interop.

The solution

In order to implement a solution, I built a C# ASP.NET project in Visual Studio .NET 2003 with the following structure:

In a nutshell, the Default.apsx page is the front end, the DocMerger performs the actual merging and the documents are located in the "files" folder ("OriginalDoc" contains the original version of the document, "Copies" is where all the uploaded files from the users reside, and "Output" is the folder in which the summarized document is generated).

The web form is fairly simple and allows downloading the original document, uploading a modified version and creating the output document.

The initial version is published in the server with the "Track Changes" option turned on, so every change the user does will be easily recognized.

Let's suppose this is the document:

The upload logic in the web page is quite straightforward: It creates a unique name for the changed document (I did this trick with Guid.NewGuid()), and then it stores the file in the "Copies" folder.

private void btnGo_Click(object sender, System.EventArgs e)
{
 string strBaseDir = Server.MapPath("files/copies");
 string strFileName = Guid.NewGuid().ToString().Replace("{","").Replace("}","");
 upload.PostedFile.SaveAs(Path.Combine(strBaseDir, strFileName + ".doc"));
}

Following our previous example, let's say three users changed the document separately.

User 1

User 2

User 3

In the "copies" folder are located all the copies that different users submitted:

The DocMerger class has a Merge method that performs the document combination. I wrote an overload with a folder name instead of a file list.

/// <summary>
/// Merge a document with a set of copies
/// </summary>
/// <param name="strOrgDoc">
/// Original file name
/// </param>
/// <param name="arrCopies">
/// File names of the modified files
/// </param>
/// <param name="strOutDoc">
/// The result filename
/// </param>
public void Merge(string strOrgDoc, string[] arrCopies, string strOutDoc)
{
  ApplicationClass objApp = null;

  //boxing of default values for COM interop purposes
  object objMissing = Missing.Value;
  object objFalse = false;
  object objTarget = WdMergeTarget.wdMergeTargetSelected;
  object objUseFormatFrom = WdUseFormattingFrom.wdFormattingFromSelected;

  try
  {
    objApp = new ApplicationClass();
    object objOrgDoc = strOrgDoc;

    Document objDocLast = null;
    Document objDocBeforeLast = null;

    objDocLast = objApp.Documents.Open(
      ref objOrgDoc,    //FileName
      ref objMissing,   //ConfirmVersions
      ref objMissing,   //ReadOnly
      ref objMissing,   //AddToRecentFiles
      ref objMissing,   //PasswordDocument
      ref objMissing,   //PasswordTemplate
      ref objMissing,   //Revert
      ref objMissing,   //WritePasswordDocument
      ref objMissing,   //WritePasswordTemplate
      ref objMissing,   //Format
      ref objMissing,   //Enconding
      ref objMissing,   //Visible
      ref objMissing,   //OpenAndRepair
      ref objMissing,   //DocumentDirection
      ref objMissing,   //NoEncodingDialog
      ref objMissing    //XMLTransform
      );

    foreach(string strCopy in arrCopies)
    {
      Debug.WriteLine("Merging file " + strCopy);
      objDocLast.Merge(
        strCopy,                //FileName
        ref objTarget,          //MergeTarget
        ref objMissing,         //DetectFormatChanges
        ref objUseFormatFrom,   //UseFormattingFrom
        ref objMissing          //AddToRecentFiles
        );
      objDocBeforeLast = objDocLast;
      objDocLast = objApp.ActiveDocument;
      Debug.WriteLine("The active document is " + objDocLast.Name);

      if (objDocBeforeLast != null)
      {
        Debug.WriteLine("Closing " + objDocBeforeLast.Name);
        objDocBeforeLast.Close(
          ref objFalse,     //SaveChanges
          ref objMissing,   //OriginalFormat
          ref objMissing    //RouteDocument
          );
      }


    }

    object objOutDoc = strOutDoc;

    objDocLast.SaveAs(
      ref objOutDoc,      //FileName
      ref objMissing,     //FileFormat
      ref objMissing,     //LockComments
      ref objMissing,     //PassWord
      ref objMissing,     //AddToRecentFiles
      ref objMissing,     //WritePassword
      ref objMissing,     //ReadOnlyRecommended
      ref objMissing,     //EmbedTrueTypeFonts
      ref objMissing,     //SaveNativePictureFormat
      ref objMissing,     //SaveFormsData
      ref objMissing,     //SaveAsAOCELetter,
      ref objMissing,     //Encoding
      ref objMissing,     //InsertLineBreaks
      ref objMissing,     //AllowSubstitutions
      ref objMissing,     //LineEnding
      ref objMissing      //AddBiDiMarks
      );

    foreach(Document objDocument in objApp.Documents)
    {
      objDocument.Close(
        ref objFalse,     //SaveChanges
        ref objMissing,   //OriginalFormat
        ref objMissing    //RouteDocument
        );
    }

  }
  finally
  {
    objApp.Quit(
      ref objMissing,     //SaveChanges
      ref objMissing,     //OriginalFormat
      ref objMissing      //RoutDocument
      );
    objApp = null;
  }
}

/// <summary>
/// Merge a document with a set of copies
/// </summary>
/// <param name="strOrgDoc">
/// Original file name
/// </param>
/// <param name="strCopyFolder">
/// Folder in which the copies are located
/// </param>
/// <param name="strOutDoc">
/// The result filename
/// </param>
public void Merge(string strOrgDoc, string strCopyFolder, string strOutDoc)
{
  string[] arrFiles = Directory.GetFiles(strCopyFolder);
  Merge(strOrgDoc, arrFiles, strOutDoc);
}

The WebForm invokes this method:

private void btnMerge_Click(object sender, System.EventArgs e)
{
  string strOrigFile = Server.MapPath("files/originaldoc/thedocument.doc");
  string strCopiesDir = Server.MapPath("files/copies");
  string strOutputDir = Server.MapPath("files/output/output.doc");
  DocMerger objMerger = new DocMerger();
  objMerger.Merge(strOrigFile, strCopiesDir, strOutputDir);
  lnkResult.NavigateUrl = "files/output/output.doc";
  lnkResult.Visible = true;
}

The final outcome is a document with the changes proposed by all the users:

This way, the administrator will be able to see just in one place all the changes and either approve or reject each one of them.

The code of this simple application could be found with this article, but there's a couple of thinks you must keep in mind:

• I generated the interop assemblies for Office 2003. You have to re-import the Office's type libraries (I think it will work in Office XP, 2000 and even in 97) and recompile the project
• Microsoft discourages the use of Office Automation in a web server. Nonetheless, all the tests that I did were fine. However, if needed, the DocMerger class could be moved to another kind of project and replace the front end with a Console or a WinForm Application.

Conclusion

By using automation in the .NET framework, taking advantage of Office's features is simple, and it allows the delivery of quick-to-implement and cool-featured solutions.

History

• 2004/06/29 - Initial upload