有没有办法加快在两个 XML 文件中查找数据更改的代码？

Question

以下代码比较两个 XML 文本并返回它们之间的数据变化的集合。

此代码运行良好，但需要尽可能资源友好。

在 LINQ 中是否有更快的方法来执行此操作，例如不创建两个 XElement 集合并比较它们的每个字段的差异？

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace TestXmlDiff8822
{
    class Program
    {
        static void Main(string[] args)
        {
            XDocument xdoc1 = XDocument.Parse(GetXml1());
            XDocument xdoc2 = XDocument.Parse(GetXml2());

            List<HistoryFieldChange> hfcList = GetHistoryFieldChanges(xdoc1, xdoc2);

            foreach (var hfc in hfcList)
            {
                Console.WriteLine("{0}: from {1} to {2}", hfc.FieldName, hfc.ValueBefore, hfc.ValueAfter);  
            }

            Console.ReadLine();
        }

        static public List<HistoryFieldChange> GetHistoryFieldChanges(XDocument xdoc1, XDocument xdoc2)
        {
            List<HistoryFieldChange> hfcList = new List<HistoryFieldChange>();

            var elements1 = from e in xdoc1.Root.Elements()
                           select e;

            var elements2 = from e in xdoc2.Root.Elements()
                           select e;

            for (int i = 0; i < elements1.Count(); i++)
            {
                XElement element1 = elements1.ElementAt(i);
                XElement element2 = elements2.ElementAt(i);

                if (element1.Value != element2.Value)
                {
                    HistoryFieldChange hfc = new HistoryFieldChange();
                    hfc.EntityName = xdoc1.Root.Name.ToString();
                    hfc.FieldName = element1.Name.ToString();
                    hfc.KindOfChange = "fieldDataChange";
                    hfc.ObjectReference = (xdoc1.Descendants("Id").FirstOrDefault()).Value;
                    hfc.ValueBefore = element1.Value;
                    hfc.ValueAfter = element2.Value;
                    hfcList.Add(hfc);
                }
            }

            return hfcList;
        }

        public static string GetXml1()
        {
            return @"
<Customer>
    <Id>111</Id>
    <FirstName>Sue</FirstName>
    <LastName>Smith</LastName>
</Customer>
";
        }



        public static string GetXml2()
        {
            return @"
<Customer>
    <Id>111</Id>
    <FirstName>Sue2</FirstName>
    <LastName>Smith-Thompson</LastName>
</Customer>
";
        }
    }

    public class HistoryFieldChange
    {
        public string EntityName { get; set; }
        public string FieldName { get; set; }
        public string ObjectReference { get; set; }
        public string KindOfChange { get; set; }
        public string ValueBefore { get; set; }
        public string ValueAfter { get; set; }
    }
}

Answer 1

您应该能够使用元素名称上的 linq 连接来获取具有不同值的所有元素。

var name = xdoc1.Root.Name.ToString();
var id = (xdoc1.Descendants("Id").FirstOrDefault()).Value;

var diff =  from o in xdoc1.Root.Elements()
        join n in xdoc2.Root.Elements() on o.Name equals n.Name
        where o.Value != n.Value
        select new HistoryFieldChange() {
                EntityName = name,
                FieldName = o.Name.ToString(),
                KindOfChange = "fieldDataChange",
                ObjectReference = id,
                ValueBefore = o.Value,
                ValueAfter = n.Value,
        };

这种方法的一个优点是它很容易为多核机器并行化，只需使用 PLinq 和 AsParallel 扩展方法。

var diff =  from o in xdoc1.Root.Elements()
        join n in xdoc2.Root.Elements().AsParallel() on o.Name equals n.Name
        where o.Value != n.Value
        ...

瞧，如果查询可以在您的计算机上并行化，那么 PLinq 将自动处理它。这将加快大型文档的速度，但如果您的文档很小，您可以通过并行化调用 GetHistoryFieldChanges 的外部循环使用类似 Parallel.For 来获得更好的加速。

另一个好处是你可以简单地从GetHistoryFieldChanges返回IEnumerable，不需要浪费时间分配一个List，项目将在枚举时返回，直到那时才执行Linq查询。

IEnumerable<HistoryFieldChange> GetHistoryFieldChanges(...)

这里是原始、Yannick 的有序和我的非并行 Linq-only 实现的 1M 次迭代的时间。在我的 2.8ghz 笔记本电脑上运行 this code。

Elapsed Orig    3262ms
All Linq        1761ms
In Order Only   2383ms

我注意到一件有趣的事情......在调试模式下运行代码，然后在发布模式下运行，编译器可以优化纯 Linq 版本的程度令人惊讶。我认为返回 IEnumerable 对编译器有很大帮助。

Answer 2

编辑：

我必须承认，我没想到 LINQ 实现会比使用有序数据的幼稚迭代方法更快。但这表明性能瓶颈并不总是在明显的地方。

正如我所说的，我假设您按顺序进行比较是有原因的，所以也许这个实现仍然可以使用。当然，它不像 joshperry 的实现那样清晰。但就性能而言，它应该夺冠。

static public IEnumerable<HistoryFieldChange> GetHistoryFieldChanges2(XDocument xdoc1, XDocument xdoc2)
{
  string id = xdoc1.Descendants("Id").FirstOrDefault().Value;
  string name = xdoc1.Root.Name.ToString();

  IEnumerator<XElement> enumerator1 = xdoc1.Root.Elements().GetEnumerator();
  IEnumerator<XElement> enumerator2 = xdoc2.Root.Elements().GetEnumerator();

  for (; enumerator1.MoveNext() && enumerator2.MoveNext(); )
  {
    XElement element1 = enumerator1.Current;
    XElement element2 = enumerator2.Current;

    if (element1.Value != element2.Value)
    {
      HistoryFieldChange hfc = new HistoryFieldChange();
      hfc.EntityName = name;
      hfc.FieldName = element1.Name.ToString();
      hfc.KindOfChange = "fieldDataChange";
      hfc.ObjectReference = id;
      hfc.ValueBefore = element1.Value;
      hfc.ValueAfter = element2.Value;
      yield return hfc;
    }
  }
}

Answer 3

您是否考虑过使用XmlDiff？