前言
上集介绍了使用XmlWriter如何写一个大型的xml，不难发现XmlWriter使用起来略比Linq to Xml麻烦一些，不过优势却是基本不消耗内存。不过XmlWriter的功能仅仅是写Xml，要读取Xml则需要依靠XmlReader，这就是今天的主角。
准备工作
首先，来准备一个大型的xml：
static void CreateLargeXmlFile(string fileName) { using (var writer = XmlWriter.Create(fileName, new XmlWriterSettings { Indent = true })) { writer.WriteStartDocument(); writer.WriteStartElement("root"); for (int i = 0; i < 100; i++) { writer.WriteStartElement("folder"); writer.WriteAttributeString("name", i.ToString()); for (int j = 0; j < 100; j++) { writer.WriteStartElement("folder"); writer.WriteAttributeString("name", j.ToString()); for (int k = 0; k < 1000; k++) { writer.WriteStartElement("file"); writer.WriteAttributeString("name", k.ToString()); writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteEndDocument(); } }
基础
首先来看一下一个代码演示如何最简单的使用XmlReader：
using (var reader = XmlReader.Create("LargeXmlFile.xml")) { while (reader.ReadToFollowing("file")) { var name = reader.GetAttribute("name"); if (name.EndsWith("0")) Console.WriteLine(name); } }
这段代码将打印出xml中所有file节点，并且name是以”0”为结尾的name属性。
当然XmlReader还有不少的方法，不过这样使用，实在是太累了，对于大多数的操作而言，Linq to Xml的API已经足够强大了，所以不妨依葫芦画瓢，来一个简易版的Linq to XmlReader。
扩展方法Elements
首先仿造一个Linq to Xml的Elements方法：
public static IEnumerable<XmlReader> Elements(this XmlReader reader, string name) { reader.Read(); while (reader.ReadToNextSibling(name)) { var result = reader.ReadSubtree(); result.Read(); yield return result; result.Close(); } }乍一看这个方法出奇的简单，但是注意，这里运用了c# 2.0的yield语法，才能简化到如此简单的6句语句。
来看看怎么使用这个扩展方法：
private static void ReadByReader() { using (var reader = XmlReader.Create("LargeXmlFile.xml")) { foreach (var item in from x in reader.Elements("root").First().Elements("folder") let parentName = x.GetAttribute("name") where int.Parse(parentName) % 20 == 0 from y in x.Elements("folder") let folderName = y.GetAttribute("name") where int.Parse(folderName) % 30 == 0 select string.Format("folder:{0}\tfolder:{1}", parentName, folderName)) { Console.WriteLine(item); } } }
folder:0 folder:0
folder:0 folder:30
folder:0 folder:60
folder:0 folder:90
folder:20 folder:0
folder:20 folder:30
folder:20 folder:60
folder:20 folder:90
folder:40 folder:0
folder:40 folder:30
folder:40 folder:60
folder:40 folder:90
folder:60 folder:0
folder:60 folder:30
folder:60 folder:60
folder:60 folder:90
folder:80 folder:0
folder:80 folder:30
folder:80 folder:60
folder:80 folder:90
这就是需要的结果，不过注意，在这个方法运行期间，整个应用程序的内存占用几乎维持在初始的内存占用状态（7M），完全无视读取的文件的巨大尺寸。
不过要注意的是这个扩展是有部分问题的，因为XmlReader是用流的方式工作的，所以有些写法会产生不想要的结果，例如：
private static void ReadByReader_Incorrect() { using (var reader = XmlReader.Create("LargeXmlFile.xml")) { foreach (var item in from x in reader.Elements("root").First().Elements("folder") where int.Parse(x.GetAttribute("name")) % 20 == 0 from y in x.Elements("folder") where int.Parse(y.GetAttribute("name")) % 30 == 0 select string.Format("folder:{0}\tfolder:{1}", x.GetAttribute("name"), y.GetAttribute("name"))) { Console.WriteLine(item); } } }
看看和正确版本的区别吧，少了let语句，表面上看语义是完全正确的，但是，实际上x和y这两个XmlReader是共用一个流的，也就是说y移动了流的位置之后，x的流位置也被移动了，所以运行出来的结果是：
folder:0 folder:0
folder:30 folder:30
folder:60 folder:60
folder:90 folder:90
folder:0 folder:0
folder:30 folder:30
folder:60 folder:60
folder:90 folder:90
folder:0 folder:0
folder:30 folder:30
folder:60 folder:60
folder:90 folder:90
folder:0 folder:0
folder:30 folder:30
folder:60 folder:60
folder:90 folder:90
folder:0 folder:0
folder:30 folder:30
folder:60 folder:60
folder:90 folder:90
不难发现，x和y的读取出来的内容是完全一样的，这显然是这个扩展方法本身的缺陷。但是只要注意这些缺陷，还是可以在很大程度上简化编程的。
扩展方法Descendants
模仿完Elements，再来模仿一个Descendants：
public static IEnumerable<XmlReader> Descendants(this XmlReader reader, string name) { reader.Read(); while (reader.ReadToFollowing(name)) { var result = reader.ReadSubtree(); result.Read(); yield return result; result.Close(); } }
还是6句，还是得益于yield语法，而且还是有缺陷。再看看例子吧：
private static void ReadByReader_Another() { using (var reader = XmlReader.Create("LargeXmlFile.xml")) { foreach (var item in from x in reader.Descendants("folder") let folder = x.GetAttribute("name") where folder == "66" from y in x.Descendants("file") let file = y.GetAttribute("name") where file == "666" select string.Format("folder:{0}\tfile:{1}", folder, file)) { Console.WriteLine(item); } } }
这里的Descendants不会查找出folder下面的folder，也就是这里的Descendants(“folder”)仅仅返回最外层的folder节点序列，这一点和Linq to Xml的Descendants不同（也不符合Xml的子孙轴的定义），主要是还没有找到相应的解决方案。
性能比较
扩展方法就暂时到这里，接下来来比较读取xml的性能比较。
比较双方：XmlReader加上文中的两个扩展 vs Linq to Xml
理论比较：
- XmlReader使用只进流的方式工作，因此不需要占用很大的内存，Linq to Xml使用in-memory的方式工作，因此内存占用与Xml的大小有关
- XmlReader每次读取都要读取流所在的真实存储介质（测试中是文件），Linq to Xml的Load本身需要一次完整的加载，但是Load出来的结果是可以缓存下来的，而只有地查找就仅仅是一次内存查找了
测试工具：最近CodeTimer比较流行，就用这个吧
测试环境：Windows XP，Release
测试数据：前面产生的250M左右的大型Xml，一个使用下面的code产生的小型xml（29K）
static void CreateSmallXmlFile(string fileName) { using (var writer = XmlWriter.Create(fileName, new XmlWriterSettings { Indent = true })) { writer.WriteStartDocument(); writer.WriteStartElement("root"); for (int i = 0; i < 10; i++) { writer.WriteStartElement("folder"); writer.WriteAttributeString("name", i.ToString()); for (int j = 0; j < 10; j++) { writer.WriteStartElement("folder"); writer.WriteAttributeString("name", j.ToString()); for (int k = 0; k < 10; k++) { writer.WriteStartElement("file"); writer.WriteAttributeString("name", k.ToString()); writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteEndDocument(); } }
测试代码：
static void ReadByReader(string fileName) { using (var reader = XmlReader.Create(fileName)) foreach (var item in from x in reader.Elements("root").First().Elements("folder") where x.GetAttribute("name") == "66" from y in x.Descendants("file") where y.GetAttribute("name") == "666" select y.GetAttribute("name")) ; } static void ReadByLinq_NoCache(string fileName) { XDocument doc = XDocument.Load(fileName); foreach (var item in from x in doc.Root.Elements("folder") where (string)x.Attribute("name") == "66" from y in x.Descendants("file") where (string)y.Attribute("name") == "666" select (string)x.Attribute("name")) ; } static XDocument m_doc; static void ReadByLinq_Cache(string fileName) { if (m_doc == null) m_doc = XDocument.Load(fileName); foreach (var item in from x in m_doc.Root.Elements("folder") where (string)x.Attribute("name") == "66" from y in x.Descendants("file") where (string)y.Attribute("name") == "666" select (string)x.Attribute("name")) ; }
然后是Main方法：
Console.Write("Ready:"); string fileName = "LargeXmlFile.xml"; int turnCount = 10; Console.ReadLine(); CodeTimer.Time("Read by Xml Reader", turnCount, () => ReadByReader(fileName)); //CodeTimer.Time("Read by Linq to Xml (cache)", turnCount, () => ReadByLinq_Cache(fileName)); //CodeTimer.Time("Read by Linq to Xml (no cache)", turnCount, () => ReadByLinq_NoCache(fileName)); Console.ReadLine();
每次执行仅仅跑一个测试，避免不必要的误差，大xml文件仅跑10次，要不然时间太长，小xml文件跑1000次，结果如下：
大Xml文件测试结果：
Ready:
Read by Xml Reader
Time Elapsed: 81,106ms
Time Elapsed (one time):8,110ms
CPU time: 81,062,500,000ns
CPU time (one time): 8,106,250,000ns
Gen 0: 310
Gen 1: 5
Gen 2: 0
内存占用停留在8M
Ready:
Read by Linq to Xml (cache)
Time Elapsed: 153,335ms
Time Elapsed (one time):15,333ms
CPU time: 77,687,500,000ns
CPU time (one time): 7,768,750,000ns
Gen 0: 209
Gen 1: 171
Gen 2: 27
内存占用800余M，由于Windows动用了虚拟内存，所以即使Cache了Xml的内容，速度依然很糟糕
Ready:
Read by Linq to Xml (no cache)
Time Elapsed: 1,100,787ms
Time Elapsed (one time):110,078ms
CPU time: 532,859,375,000ns
CPU time (one time): 53,285,937,500ns
Gen 0: 1645
Gen 1: 1131
Gen 2: 124
内存10次上涨到800余M，笔记本被痛苦的折磨了以后，终于得到结果了。。。
对大型Xml文件来说，XmlReader以极小的内存占用和极少的垃圾对象完胜。
接下来是小型Xml文件的测试代码：
Console.Write("Ready:"); string fileName = "SmallXmlFile.xml"; int turnCount = 1000; Console.ReadLine(); CodeTimer.Time("Read by Xml Reader", turnCount, () => ReadByReader(fileName)); //CodeTimer.Time("Read by Linq to Xml (cache)", turnCount, () => ReadByLinq_Cache(fileName)); //CodeTimer.Time("Read by Linq to Xml (no cache)", turnCount, () => ReadByLinq_NoCache(fileName)); Console.ReadLine();
看看测试结果：
Ready:
Read by Xml Reader
Time Elapsed: 1,835ms
Time Elapsed (one time):1ms
CPU time: 1,156,250,000ns
CPU time (one time): 1,156,250ns
Gen 0: 19
Gen 1: 0
Gen 2: 0
内存几乎没增加，没有1代和2代的垃圾
Ready:
Read by Linq to Xml (cache)
Time Elapsed: 258ms
Time Elapsed (one time):0ms
CPU time: 31,250,000ns
CPU time (one time): 31,250ns
Gen 0: 0
Gen 1: 0
Gen 2: 0
速度飞快，并且没有垃圾产生（因为整个XDocument还被缓存引用着）
Ready:
Read by Linq to Xml (no cache)
Time Elapsed: 1,589ms
Time Elapsed (one time):1ms
CPU time: 1,546,875,000ns
CPU time (one time): 1,546,875ns
Gen 0: 74
Gen 1: 11
Gen 2: 0
Xml比较小，所以没有内存压力，但是有1代的垃圾
小Xml文件的测试结果表明，Linq to Xml的主要代价在加载Xml本身，查找的代价非常小，也就是有Cache时，整个过程的时间仅仅是No Cache的1/6，而XmlReader方式无法Cache。
在同样No Cache的情况下，XmlReader的使用时间较长（多消耗15%），但是GC的压力相对较小（少消耗25%），同时CPU time也略小于Linq to Xml。
结论
如果仅仅是读取Xml的话，XmlReader的优势还是相当大的。当Xml很大时，XmlReader是唯一能保证内存不会成为制约因素的读取方式，即使Xml文件不是很大的情况下，XmlReader也不会落后于其他方式太多。要说缺点的话，最大的确定就是API并不怎么容易使用，除非自己添加扩展方法。
下集预告
还有下集吗？Xml的东西太多了，要讲总是有东西可讲的，下集主要介绍一下Xml序列化，不过Xml序列化本身的内容就非常多，单独拿出来写一个系列都可以，所以下集仅仅是一个相对比较简单的介绍。
