转载自：http://virgos.javaeye.com/blog/611146
一．前言：
XML是微软.Net战略的一个重要组成部分，而且它可谓是XML Web服务的基石，所以掌握.Net框架下的XML技术自然显得非常重要了。本文将指导大家如何运用C#语言完成.Net框架下的XML文档的读写操作。首先，我会向大家介绍.Net框架中与XML相关的命名空间和其中的重要类。其次，我还会给出有关的实例以使读者更进一步的了解XML文档的读写操作的具体方法。
二．XML命名空间和相关类简介：
在深入进行.Net框架下的XML文档的操作之前，我想很有必要向大家介绍.Net框架中与XML技术有关的命名空间和其中一些重要的类。.Net 框架为我们提供了以下一些命名空间：System.Xml、System.Xml.Schema、 System.Xml.Serialization、System.Xml.Xpath以及 System.Xml.Xsl来包容和XML操作相关的类。
System.Xml命名空间包含了一些最重要的XML类，其中最主要的类是和XML文档的读写操作相关的类。这些类中包括4个与读相关的类以及 2 个与写相关的类。它们分别是：XmlReader、XmlTextReader、 XmlValidatingReader、XmlNodeReader、XmlWriter以及 XmlTextWriter。本文将重点介绍这些类，因为它们是最基本也是最重要的类。
XmlReader类是一个虚基类，它包含了读XML文档的方法和属性。该类中的Read方法是一个基本的读XML文档的方法，它以流形式读取 XML文档中的节点（Node）。另外，该类还提供了ReadString、ReadInnerXml、 ReadOuterXml和ReadStartElement等更高级的读方法。除了提供读XML文档的方法外，XmlReader类还为程序员提供了 MoveToAttribute、MoveToFirstAttribute、MoveToContent、MoveToFirstContent、 MoveToElement以及 MoveToNextAttribute等具有导航功能的方法。在本文后面介绍的实例中，我们将运用到这些方法。
XmlTextReader、XmlNodeReader以及XmlValidatingReader等类是从XmlReader类继承过来的子类。根据它们的名称，我们可以知道其作用分别是读取文本内容、读取节点和读取XML模式（Schemas）。
XmlWriter类为程序员提供了许多写XML文档的方法，它是XmlTextWriter类的基类，我在后面的实例中会给出相关的运用方法。
XmlNode类是一个非常重要的类，它代表了XML文档中的某个节点。该节点可以是XML文档的根节点，这样它就代表整个XML文档了。它是许多很有用的类的基类，这些类包括插入节点的类、删除节点的类、替换节点的类以及在XML文档中完成导航功能的类。同时，XmlNode类还为程序员提供了获取双亲节点、子节点、最后一个子节点、节点名称以及节点类型等的属性。它的三个最主要的子类包括： XmlDocument、XmlDataDocument以及XmlDocumentFragment。XmlDocument类代表了一个XML文档，它提供了载入和保存XML文档的方法和属性。这些方法包括了Load、LoadXml和Save等。同时，它还提供了添加特性（Attributes）、说明（Comments）、空间（Spaces）、元素（Elements）和新节点（New Nodes）等XML项的功能。XmlDocumentFragment类代表了一部分XML文档，它能被用来添加到其他的XML文档中。 XmlDataDocument类可以让程序员更好地完成和ADO.NET中的数据集对象之间的互操作。
除了上面介绍的System.Xml命名空间中的类外，该命名空间还包括了XmlConvert、XmlLinkedNode以及 XmlNodeList等类，不过这些类不是本文介绍的重点，有兴趣的读者不妨去参考相关文档资料。
System.Xml.Schema命名空间中包含了和XML模式相关的类，这些类包括XmlSchema、XmlSchemaAll、 XmlSchemaXPath以及XmlSchemaType等类。
System.Xml.Serialization命名空间中包含了和XML文档的序列化和反序列化操作相关的类，XML文档的序列化操作能将 XML格式的数据转化为流格式的数据并能在网络中传输，而反序列化则完成相反的操作，即将流格式的数据还原成XML格式的数据。
System.Xml.XPath命名空间包含了XPathDocument、 XPathExression、XPathNavigator以及XPathNodeIterator等类，这些类能完成XML文档的导航功能。在 XPathDocument类的协助下，XPathNavigator类能完成快速的XML文档导航功能，该类为程序员提供了许多Move方法以完成导航功能。
System.Xml.Xsl命名空间中的类完成了XSLT的转换功能。
三．读XML文档的方法：
在介绍完.Net框架中和XML有关的命名空间和相关类后，我接着向大家介绍和XML相关的一些操作。首先，我向大家介绍的读取XML文档的方法。在下面的实例程序中，我将运用VS.net开发工具附带的"books.xml"文件来作为示例。你可以在你的机器上搜索到该文件（或请参考附录），或者你也可以运用其他的XML文件。
首先，我们用XmlTextReader类的对象来读取该XML文档。方法很简单，就是在创建新对象的构造函数中指明XML文件的位置即可。
XmlTextReader textReader = new XmlTextReader("C://books.xml");
一旦新对象创建完毕，你就可以调用其Read方法来读取XML文档了。调用Read方法之后，信息被存储起来，你可以通过读取该对象的Name、 BaseURI、Depth、LineNumber等属性来获取这些信息。下面我给出一个完整的实例，该实例通过简单的读取"books.xml"文件，然后将其中的信息显示在控制台中。
C#代码
1. using System;
2. using System.Xml;
3.
4. namespace ReadXml
5. {
6. class Class1
7. {
8. static void Main( string[] args )
9. {
10. // 创建一个XmlTextReader类的对象并调用Read方法来读取文件
11. XmlTextReader textReader = new XmlTextReader("C://books.xml");
12. textReader.Read();
13. // 节点非空则执行循环体
14. while ( textReader.Read() )
15. {
16. // 读取第一个元素
17. textReader.MoveToElement();
18. Console.WriteLine("XmlTextReader Properties Test");
19. Console.WriteLine("===================");
20.
21. // 读取该元素的属性并显示在控制台中
22. Console.WriteLine("Name:" + textReader.Name);
23. Console.WriteLine("Base URI:" + textReader.BaseURI);
24. Console.WriteLine("Local Name:" + textReader.LocalName);
25. Console.WriteLine("Attribute Count:" + textReader.AttributeCount.ToString());
26. Console.WriteLine("Depth:" + textReader.Depth.ToString());
27. Console.WriteLine("Line Number:" + textReader.LineNumber.ToString());
28. Console.WriteLine("Node Type:" + textReader.NodeType.ToString());
29. Console.WriteLine("Attribute Count:" + textReader.Value.ToString());
30. }
31. }
32. }
33. }
XmlTextReader类中有一个很重要的属性－NodeType，通过该属性，我们可以知道其节点的节点类型。而枚举类型 XmlNodeType中包含了诸如Attribute、CDATA、Element、Comment、 Document、DocumentType、Entity、ProcessInstruction以及WhiteSpace等的XML项的类型。通过与 XmlNodeType中的元素的比较，我们可以获取相应节点的节点类型并对其完成相关的操作。下面我就给出一个实例，该实例读取每个节点的 NodeType，并根据其节点类型显示其中的内容，同时程序还记录了XML文件中每种节点类型的数目。
C#代码
1. using System;
2. using System.Xml;
3.
4. namespace ReadXML
5. {
6. class Class2
7. {
8. static void Main( string[] args )
9. {
10. int ws = 0;
11. int pi = 0;
12. int dc = 0;
13. int cc = 0;
14. int ac = 0;
15. int et = 0;
16. int el = 0;
17. int xd = 0;
18.
19. XmlTextReader textReader = new XmlTextReader("C://books.xml");
20.
21. while (textReader.Read())
22. {
23. XmlNodeType nType = textReader.NodeType;
24.
25. // 节点类型为XmlDeclaration
26. if (nType == XmlNodeType.XmlDeclaration)
27. {
28. Console.WriteLine("Declaration:" + textReader.Name.ToString());
29. xd = xd + 1;
30. }
31.
32. // 节点类型为Comment
33. if( nType == XmlNodeType.Comment)
34. {
35. Console.WriteLine("Comment:" + textReader.Name.ToString());
36. cc = cc + 1;
37. }
38.
39. // 节点类型为Attribute
40. if( nType == XmlNodeType.Attribute)
41. {
42. Console.WriteLine("Attribute:" + textReader.Name.ToString());
43. ac = ac + 1;
44. }
45.
46. // 节点类型为Element
47. if ( nType == XmlNodeType.Element)
48. {
49. Console.WriteLine("Element:" + textReader.Name.ToString());
50. el = el + 1;
51. }
52.
53. // 节点类型为Entity
54. if ( nType == XmlNodeType.Entity )
55. {
56. Console.WriteLine("Entity:" + textReader.Name.ToString());
57. et = et + 1;
58. }
59.
60. // 节点类型为Process Instruction
61. if( nType == XmlNodeType.ProcessingInstruction )
62. {
63. Console.WriteLine("Process Instruction:" + textReader.Name.ToString());
64. pi = pi + 1;
65. }
66.
67. // 节点类型为DocumentType
68. if( nType == XmlNodeType.DocumentType)
69. {
70. Console.WriteLine("DocumentType:" + textReader.Name.ToString());
71. dc = dc + 1;
72. }
73.
74. // 节点类型为Whitespace
75. if ( nType == XmlNodeType.Whitespace )
76. {
77. Console.WriteLine("WhiteSpace:" + textReader.Name.ToString());
78. ws = ws + 1;
79. }
80. }
81.
82. // 在控制台中显示每种类型的数目
83. Console.WriteLine("Total Comments:" + cc.ToString());
84. Console.WriteLine("Total Attributes:" + ac.ToString());
85. Console.WriteLine("Total Elements:" + el.ToString());
86. Console.WriteLine("Total Entity:" + et.ToString());
87. Console.WriteLine("Total Process Instructions:" + pi.ToString());
88. Console.WriteLine("Total Declaration:" + xd.ToString());
89. Console.WriteLine("Total DocumentType:" + dc.ToString());
90. Console.WriteLine("Total WhiteSpaces:" + ws.ToString());
91. }
92. }
93. }
以上，我向大家介绍了如何运用XmlTextReader类的对象来读取XML文档，并根据节点的NodeType属性来取得其节点类型信息。同时 XmlReader这个基类还有XmlNodeReader和 XmlValidatingReader等派生类，它们分别是用来读取XML文档的节点和模式的。限于篇幅，这里就不介绍了，读者可以参考有关资料。
四．写XML文档的方法：
XmlWriter类包含了写XML文档所需的方法和属性，它是XmlTextWriter类和 XmlNodeWriter类的基类。该类包含了WriteNode、WriteString、WriteAttributes、 WriteStartElement以及WriteEndElement等一系列写XML文档的方法，其中有些方法是成对出现的。比如你要写入一个元素，你首先得调用WriteStartElement方法，接着写入实际内容，最后是调用WriteEndElement方法以表示结束。该类还包含了 WriteState、XmlLang和XmlSpace等属性，其中WriteState属性表明了写的状态。因为XmlWriter类包含了很多写 XML文档的方法，所以这里只是介绍最主要的几种。下面我们通过其子类XmlTextWriter类来说明如何写XML文档。
首先，我们要创建一个XmlTextWriter类的实例对象。该类的构造函数 XmlTextWriter有三种重载形式，其参数分别为一个字符串、一个流对象和一个TextWriter对象。这里我们运用字符串的参数形式，该字符串就指明了所要创建的XML文件的位置，方法如下：
XmlTextWriter textWriter = New XmlTextWriter("C://myXmFile.xml", null);
在创建完对象后，我们调用WriterStartDocument方法开始写XML文档，在完成写工作后，就调用 WriteEndDocument 结束写过程并调用Close方法将它关闭。在写的过程中，我们可以调用WriteComment方法来添加说明，通过调用WriteString方法来添加一个字符串，通过调用WriteStartElement和WriteEndElement方法对来添加一个元素，通过调用 WriteStartAttribute和WriteEndAttribute方法对来添加一个属性。我们还可以通过调用 WriteNode方法来添加整一个节点，其它的写的方法还包括WriteProcessingInstruction和WriteDocType等等。下面的实例就是介绍如何具体运用这些方法来完成XML文档的写工作的。
C#代码
1. using System;
2. using System.Xml;
3.
4. namespace WriteXML
5. {
6. class Class1
7. {
8. static void Main( string[] args )
9. {
10. try
11. {
12. // 创建XmlTextWriter类的实例对象
13. XmlTextWriter textWriter = new XmlTextWriter("C://w3sky.xml", null);
14. textWriter.Formatting = Formatting.Indented;
15.
16. // 开始写过程，调用WriteStartDocument方法
17. textWriter.WriteStartDocument();
18.
19. // 写入说明
20. textWriter.WriteComment("First Comment XmlTextWriter Sample Example");
21. textWriter.WriteComment("w3sky.xml in root dir");
22.
23. //创建一个节点
24. textWriter.WriteStartElement("Administrator");
25. textWriter.WriteElementString("Name", "formble");
26. textWriter.WriteElementString("site", "w3sky.com");
27. textWriter.WriteEndElement();
28.
29.
30.
31. // 写文档结束，调用WriteEndDocument方法
32. textWriter.WriteEndDocument();
33.
34. // 关闭textWriter
35. textWriter.Close();
36.
37. }
38. catch(System.Exception e)
39. {
40. Console.WriteLine(e.ToString());
41. }
42. }
43. }
44. }
五．运用XmlDocument类：
XmlDocument类的对象代表了一个XML文档，它也是一个非常重要的XML类。该类包含了 Load、LoadXml以及Save等重要的方法。其中Load方法可以从一个字符串指定的XML文件或是一个流对象、一个TextReader对象、一个XmlReader对象导入XML数据。LoadXml方法则完成从一个特定的XML文件导入XML数据的功能。它的Save方法则将XML数据保存到一个XML文件中或是一个流对象、一个TextWriter对象、一个XmlWriter对象中。
下面的程序中我们用到了XmlDocument类对象的LoadXml方法，它从一个XML文档段中读取XML数据并调用其Save方法将数据保存在一个文件中。
C#代码
1. // 创建一个XmlDocument类的对象
2. XmlDocument doc = new XmlDocument();
3. doc.LoadXml(("<Student type='regular' Section='B'><Name>Tommy Lex</Name></Student>"));
4.
5. // 保存到文件中
6. doc.Save("C://student.xml");
这里，我们还可以通过改变Save方法中参数，将XML数据显示在控制台中，方法如下：
C#代码
doc.Save(Console.Out);
而在下面的程序中，我们用到了一个XmlTextReader对象，通过它我们读取 "books.xml"文件中的XML数据。然后创建一个XmlDocument对象并载入XmlTextReader对象，这样XML数据就被读到 XmlDocument对象中了。最后，通过该对象的Save方法将XML数据显示在控制台中。
C#代码
1. XmlDocument doc = new XmlDocument();
2. // 创建一个XmlTextReader对象，读取XML数据
3. XmlTextReader reader = new XmlTextReader("c://books.xml");
4. reader.Read();
5.
6. // 载入XmlTextReader类的对象
7. doc.Load(reader);
8. // 将XML数据显示在控制台中
9. doc.Save(Console.Out);
六．总结：
XML技术作为.Net的基石，其重要性自然不言而喻。.Net框架包含了五个命名空间和大量的类来支持与XML技术有关的操作。其中 System.Xml是最重要的一个命名空间，其中的XmlReader类和XmlWriter类以及它们的派生类完成了 XML文档的读写操作，是最基本也是最重要的类。XmlDocument类代表了XML文档，它能完成与整个XML文档相关的各类操作，同时和其相关的 XmlDataDocument类也是非常重要的，值得读者的深入研究。
附录
"books.xml"文件如下：
XML代码
===================================================
以上方法了解一下就行，不实用
1. XML是一项热门的技术。它之所以能够引起人们的兴趣，一个主要的原因在于它十分的简单，人们可以很容易地理解和使用它。每一个程序员都能轻易地看懂一个 XML文件，理解它包含的内容。 .NET中包含了很多支持XML的类，这些类使得程序员使用XML编程就如同理解XML文件一样简单。
在这篇文章中，我将给出这样的一个类的使用示例，这个类就是 XmlTextWriter类。 XmlTextWriter类允许你将XML写到一个文件中去。这个类包含了很多方法和属性，使用这些属性和方法可以使你更容易地处理XML。为了使用这个类，你必须首先创建一个新的XmlTextWriter对象，然后你可以将XML片断加入到这个对象中。
这个类中包含了不少的方法用于将各种类型的XML元素添加到XML文件中，下表给出了这些方法的名字和描述情况：方法描述
WriteStartDocument 书写版本为“1.0”的 XML 声明
WriteEndDocument 关闭任何打开的元素或属性
Close 关闭流
WriteDocType 写出具有指定名称和可选属性的 DOCTYPE 声明
WriteStartElement写出指定的开始标记
WriteEndElement关闭一个元素
WriteFullEndElement关闭一个元素，并且总是写入完整的结束标记
WriteElementString 写出包含字符串值的元素
WriteStartAttribute 书写属性的起始内容
WriteEndAttribute 关闭上一个 WriteStartAttribute 调用 WriteRaw手动书写原始标记 WriteString书写一个字符串
WriteAttributeString出具有指定值的属性 WriteCData写出包含指定文本的 <![CDATA[...]]> 块 WriteComment写出包含指定文本的注释 <!--...--> WriteWhiteSpace写出给定的空白 WriteProcessingInstruction写出在名称和文本之间带有空格的处理指令，如下所示：
<?name text?> 如果你对于XML十分熟悉，那么你一定能很好的理解上面的这些方法。
下面我们将给出一个例子，在这个例子中，我们将先创建一个文档，添加一些元素，然后关闭这个文档。添加了元素后你还可以添加子元素，属性和其他内容。下面的代码就是这样的一个例子，它创建了一个文件名为title的XML文件。
using System; using System.IO;
using System.Xml;
public class Sample
{
public static void Main()
{
XmlTextWriter writer = new XmlTextWriter("titles.xml", null); //写入根元素
writer.WriteStartElement("items"); //加入子元素
writer.WriteElementString("title", "Unreal Tournament 2003");
writer.WriteElementString("title", "C&C: Renegade");
writer.WriteElementString("title", "Dr. Seuss's ABC"); //关闭根元素，并书写结束标签
writer.WriteEndElement(); //将XML写入文件并且关闭
XmlTextWriter writer.Close();
}
}
如果你编译并且执行上面的代码，你将创建这个XML文件，文件中包含如下内容：
<items>
<title>Unreal Tournament 2003</title>
<title> Renegade</title>
<title>Dr. Seuss's ABC </title>
</items>
上面的代码创建了一个名为writer的XmlTextWriter对象。当这个对象被创建时，它被关联到一个名为titles.xml的文件。接着，程序创建了一个叫做items的根属性，WriteStartElement方法创建了这个属性的开始标签。
接下来，程序调用了 WriteElementString方法创建了三个子元素。从上面的代码你还可以看到，这个方法使用第一个参数（在上面的程序中是title）作为元素的标签；使用第二个参数作为元素的值。当你添加了所有的元素后，你需要关闭根元素。这时你可以调用WriteEndElement方法关闭那个最近被打开的元素；
在本例中，这个最近被打开的元素就是根元素。当所有的数据都已经写好，根元素也已经关闭时，你可以将信息传送给你的XmlTextWriter。这意味着这时候你可以调用Close方法关闭它了。上面的代码相对十分的简单，下面我们看一个使用了XmlTextWriter类中更多方法，功能更加完善的例子。
using System; using System.IO;
using System.Xml;
public class Sample
{
public static void Main()
{
XmlTextWriter writer = new XmlTextWriter("myMedia.xml", null); //使用自动缩进便于阅读
writer.formatting = formatting.Indented; //书写根元素
writer.WriteStartElement("items"); //开始一个元素
writer.WriteStartElement("item"); //向先前创建的元素中添加一个属性
writer.WriteAttributeString("rating", "R"); //添加子元素
writer.WriteElementString("title", "The Matrix");
writer.WriteElementString("format", "DVD"); //关闭item元素
writer.WriteEndElement(); // 关闭元素
//在节点间添加一些空格
writer.WriteWhitespace("n"); //使用原始字符串书写第二个元素
writer.WriteRaw("<item>" + "<title>BloodWake</title>" + "<format>XBox</format>" + "</item>"); //使用格式化的字符串书写第三个元素
writer.WriteRaw("n <item>n" + " <title>Unreal Tournament 2003</title>n" + " <format>CD</format>n" + " </item>n"); // 关闭根元素
writer.WriteFullEndElement(); //将XML写入文件并关闭
writer writer.Close();
}
}
上面代码编译运行后将得到myMedia.xml文件，文件的内容为：
<items>
<item rating="R">
<title>The Matrix</title>
<format>DVD</format>
</item>
<item>
<title>BloodWake</title>
<format>XBox</format>
</item>
<item>
<title>Unreal Tournament 2003</title>
<format>CD</format>
</item>
</items>
上面代码中的注释说明了这个程序的功能是如何实现的。需要记住的一件事是：当调用方法开始一个操作时，你需要在程序的合适的地方调用方法结束这个操作。例如，你调用了StartElement，你就必须调用EndElement关闭元素；当然在这两个调用之间你也可以加入一个子元素。无论你何时调用 EndElement方法，它总是关闭最近使用StartElement方法打开的那个元素（这和栈的工作方式很相似）。使用XmlTextWriter 十分的容易，不过我还是建议你自己动手试试这些代码和方法。你试过以后会发现这些代码能够很容易地集成到你的程序中。你还应该记住，XmlTextWriter仅仅是.NET提供的众多XML类中的一个。和XmlTextWriter一样，其他的XML类也十分的容易使用。
2.我用的是一种很笨的方法，但可以帮助初学者了解访问XML节点的过程。
已知有一个XML文件（bookstore.xml）如下：
XML代码
1、往<bookstore>节点中插入一个<book>节点：
XML代码
1. XmlDocument xmlDoc=new XmlDocument();
2. xmlDoc.Load("bookstore.xml");
3. XmlNode root=xmlDoc.SelectSingleNode("bookstore");//查找<bookstore>
4. XmlElement xe1=xmlDoc.CreateElement("book");//创建一个<book>节点
5. xe1.SetAttribute("genre"," 李赞红");//设置该节点genre属性
6. xe1.SetAttribute("ISBN","2-3631-4");//设置该节点 ISBN属性
7.
8. XmlElement xesub1=xmlDoc.CreateElement("title");
9. xesub1.InnerText="CS从入门到精通"; //设置文本节点
10. xe1.AppendChild(xesub1);//添加到<book>节点中
11. XmlElement xesub2=xmlDoc.CreateElement("author");
12. xesub2.InnerText="候捷";
13. xe1.AppendChild(xesub2);
14. XmlElement xesub3=xmlDoc.CreateElement("price");
15. xesub3.InnerText="58.3";
16. xe1.AppendChild(xesub3);
17.
18. root.AppendChild(xe1);//添加到<bookstore>节点中
19. xmlDoc.Save("bookstore.xml");
===============================================
结果为：
C#代码
1. XmlNodeList nodeList=xmlDoc.SelectSingleNode("bookstore").ChildNodes;//获取bookstore节点的所有子节点
2. foreach(XmlNode xn in nodeList)//遍历所有子节点
3. {
4. XmlElement xe=(XmlElement)xn;//将子节点类型转换为XmlElement类型
5. if(xe.GetAttribute("genre")==" 李赞红")//如果genre属性值为“李赞红”
6. {
7. xe.SetAttribute("genre","update 李赞红");//则修改该属性为“update李赞红”
8.
9. XmlNodeList nls=xe.ChildNodes;//继续获取xe子节点的所有子节点
10. foreach(XmlNode xn1 in nls)//遍历
11. {
12. XmlElement xe2=(XmlElement)xn1;//转换类型
13. if(xe2.Name=="author")// 如果找到
14. {
15. xe2.InnerText="亚胜";//则修改
16. break;//找到退出来就可以了
17. }
18. }
19. break;
20. }
21. }
22.
23. xmlDoc.Save("bookstore.xml");//保存。
==================================================
最后结果为：
XML代码
1. XmlNodeList xnl=xmlDoc.SelectSingleNode("bookstore").ChildNodes;
2.
3. foreach(XmlNode xn in xnl)
4. {
5. XmlElement xe=(XmlElement)xn;
6. if(xe.GetAttribute("genre")=="fantasy")
7. {
8. xe.RemoveAttribute("genre");// 删除genre属性
9. }
10. else if(xe.GetAttribute("genre")=="update李赞红")
11. {
12. xe.RemoveAll();// 删除该节点的全部内容
13. }
14. }
15. xmlDoc.Save("bookstore.xml");
===========================================
最后结果为：
1. <?xml version="1.0" encoding="gb2312"?>
2. <bookstore>
3. <book ISBN="2-3631-4">
4. <title>Oberon's Legacy</title>
5. <author>Corets, Eva</author>
6. <price>5.95</price>
7. </book>
8. <book>
9. </book>
10. </bookstore>
===========================================
4、显示所有数据。
XmlNode xn=xmlDoc.SelectSingleNode("bookstore");
XmlNodeList xnl=xn.ChildNodes;
foreach(XmlNode xnf in xnl)
{
XmlElement xe=(XmlElement)xnf;
Console.WriteLine(xe.GetAttribute("genre"));// 显示属性值
Console.WriteLine(xe.GetAttribute("ISBN"));
XmlNodeList xnf1=xe.ChildNodes;
foreach(XmlNode xn2 in xnf1)
{
Console.WriteLine(xn2.InnerText);//显示子节点点文本
}
}
514
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
