Question

At this moment, I am managing a piece of software that has multiple XML configuration files. When a new version of software is released, sometimes the base config files change, we currently have the software call KDiff on startup. If it detects a change, it prompts the user to choose the changes.

The problem with this approach is that KDiff is a line comparing program and not aware of the ways of XML (like Nodes, etc.)

Ideally, I would like to programmatically work with a library in C# (since we’re a MS shop) that can Diff two XML files: a Source XML and a Current Working XML.

And then Merge the two together using a few simple rules:

1. If the Current Working XML has a node that the Source XML does not, remove it.
2. If the Source XML has a node that the Current Working XML does not, add it.
3. If both have the same node and the values differ, favor the Source XML’s value, unless it the Source XML’s value is set to “UseExistingValue”.

For example, here’s the “Source” XML:

<Configuration>
  <Items>
     <Item Id="1" Position="true">
       <Location X="UseExistingValue" Y="UseExistingValue" Z="UseExistingValue" />

       <Something/>
       <SomethingElse/>
     </Item>
   </Items>
 </Configuration>

And here’s the “Current Working” XML:

<Configuration>
  <Items>
    <Item Id="1" Position="false">
      <Location X="123" Y="234" Z="345" />
      <Another/>
      <Something/>

    </Item>
  </Items>
</Configuration>

And the merged version would look like:

<Configuration>
  <Items>
    <Item Id="1" Position="true">
      <Location X="123" Y="234" Z="345" />

      <Something/>
      <SomethingElse/>
    </Item>
  </Items>
</Configuration>

I’ve looked at the MS XML Diff and Patch Tool and it definitely merges the files together, but doesn’t allow for the programmatic rules that I want to define.

XMLUnit for Java devs seems promising, but the .NET version of it seems underdeveloped, which is unfortunate.

Anyone have any suggestions for either scriptable XML Diff/Merge tools and/or .NET libraries (paid or free)?

Thanks.

Answer 1

After a couple days of messing around, I found a solution that I think works for me. Maybe it could work for other people as well.

The MS XML Diff and Patch tool was a viable option. When you Diff first file against the second file it creates an XML “DiffGram” listing what changes it detected between the two XML files.

To take care of all 3 rules that I listed above, I Diff’d the two files in one direction, then opened the DiffGram file using Linq-to-XML and Removed all the “Add” and “Remove” lines.

XNamespace xd = "http://schemas.microsoft.com/xmltools/2002/xmldiff";
var doc = XDocument.Load(_diffGramFile);
doc.Root.DescendantsAndSelf(xd + "add").Remove();
doc.Root.DescendantsAndSelf(xd + "remove").Remove();

Then I patched up (merged) this edited diffgram against the first file and created a partially merged temporary file. This takes care of Rules 1 and 2.

Next, I Diff’d the partially merged file against the first file used. Then opened the new DiffGram and removed all Change references to “UseExistingValue”.

var newdoc = XDocument.Load(_diffGramFile);
newdoc.Root.DescendantsAndSelf(xd + "change")
      .Where(x => x.Value == "UseExistingValue").Remove();

And merged this edited DiffGram against the partially merged file which takes care of Rule 3. Saving this out to XML then produces the final XML merged according to the rules defined above.

Hopefully this can help out other people.

HINT: After installing the XmlDiffPatch library, the XmlDiffPatch DLL can be found in C:\Windows\assembly\GAC\XmlDiffPatch\1.0.8.28__b03f5f7f11d50a3a\XmlDiffPatch.dll