登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›在.net中读写XML方法的总结

在.net中读写XML方法的总结

秦晓曼 2025-5-29 16:34:45
XML是一种很常见的数据保存方式，我经常用它来保存一些数据，或者是一些配置参数。使用C#，我们可以借助.net framework提供的很多API来读取或者创建修改这些XML，然而，不同人使用XML的方法很有可能并不相同。今天我打算谈谈我使用XML的一些方法，供大家参考。
最简单的使用XML的方法

由于.net framework针对XML提供了很多API，这些API根据不同的使用场景实现了不同层次的封装，比如，我们可以直接使用XmlTextReader、XmlDocument、XPath来取数XML中的数据，也可以使用LINQ TO XML或者反序列化的方法从XML中读取数据。那么，使用哪种方法最简单呢？
我个人倾向于使用序列化，反序列化的方法来使用XML。采用这种方法，我只要考虑如何定义数据类型就可以了，读写XML各只需要一行调用即可完成。例如：
  1. // 1. 首先要创建或者得到一个数据对象
  2. Order order = GetOrderById(123);
  5. // 2. 用序列化的方法生成XML
  6. string xml = XmlHelper.XmlSerialize(order, Encoding.UTF8);
  9. // 3. 从XML读取数据并生成对象
  10. Order order2 = XmlHelper.XmlDeserialize<Order>(xml, Encoding.UTF8);
复制代码
就是这么简单的事情，XML结构是什么样的，我根本不用关心，我只关心数据是否能保存以及下次是否能将它们读取出来。
说明：XmlHelper是一个工具类，全部源代码如下：
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Xml.Serialization;
  6. using System.IO;
  7. using System.Xml;
  9. // 此处代码来源于博客【在.net中读写config文件的各种方法】的示例代码
  10. // http://www.cnblogs.com/fish-li/archive/2011/12/18/2292037.html
  12. namespace <b>MyMVC</b>
  13. {
  14.     public static class XmlHelper
  15.     {
  16.         private static void XmlSerializeInternal(Stream stream, object o, Encoding encoding)
  17.         {
  18.             if( o == null )
  19.                 throw new ArgumentNullException("o");
  20.             if( encoding == null )
  21.                 throw new ArgumentNullException("encoding");
  23.             XmlSerializer serializer = new XmlSerializer(o.GetType());
  25.             XmlWriterSettings settings = new XmlWriterSettings();
  26.             settings.Indent = true;
  27.             settings.NewLineChars = "\r\n";
  28.             settings.Encoding = encoding;
  29.             settings.IndentChars = "    ";
  31.             using( XmlWriter writer = XmlWriter.Create(stream, settings) ) {
  32.                 serializer.Serialize(writer, o);
  33.                 writer.Close();
  34.             }
  35.         }
  37.         /// <summary>
  38.         /// 将一个对象序列化为XML字符串
  39.         /// </summary>
  40.         /// <param name="o">要序列化的对象</param>
  41.         /// <param name="encoding">编码方式</param>
  42.         /// <returns>序列化产生的XML字符串</returns>
  43.         public static string XmlSerialize(object o, Encoding encoding)
  44.         {
  45.             using( MemoryStream stream = new MemoryStream() ) {
  46.                 XmlSerializeInternal(stream, o, encoding);
  48.                 stream.Position = 0;
  49.                 using( StreamReader reader = new StreamReader(stream, encoding) ) {
  50.                     return reader.ReadToEnd();
  51.                 }
  52.             }
  53.         }
  55.         /// <summary>
  56.         /// 将一个对象按XML序列化的方式写入到一个文件
  57.         /// </summary>
  58.         /// <param name="o">要序列化的对象</param>
  59.         /// <param name="path">保存文件路径</param>
  60.         /// <param name="encoding">编码方式</param>
  61.         public static void XmlSerializeToFile(object o, string path, Encoding encoding)
  62.         {
  63.             if( string.IsNullOrEmpty(path) )
  64.                 throw new ArgumentNullException("path");
  66.             using( FileStream file = new FileStream(path, FileMode.Create, FileAccess.Write) ) {
  67.                 XmlSerializeInternal(file, o, encoding);
  68.             }
  69.         }
  71.         /// <summary>
  72.         /// 从XML字符串中反序列化对象
  73.         /// </summary>
  74.         /// <typeparam name="T">结果对象类型</typeparam>
  75.         /// <param name="s">包含对象的XML字符串</param>
  76.         /// <param name="encoding">编码方式</param>
  77.         /// <returns>反序列化得到的对象</returns>
  78.         public static T XmlDeserialize<T>(string s, Encoding encoding)
  79.         {
  80.             if( string.IsNullOrEmpty(s) )
  81.                 throw new ArgumentNullException("s");
  82.             if( encoding == null )
  83.                 throw new ArgumentNullException("encoding");
  85.             XmlSerializer mySerializer = new XmlSerializer(typeof(T));
  86.             using( MemoryStream ms = new MemoryStream(encoding.GetBytes(s)) ) {
  87.                 using( StreamReader sr = new StreamReader(ms, encoding) ) {
  88.                     return (T)mySerializer.Deserialize(sr);
  89.                 }
  90.             }
  91.         }
  93.         /// <summary>
  94.         /// 读入一个文件，并按XML的方式反序列化对象。
  95.         /// </summary>
  96.         /// <typeparam name="T">结果对象类型</typeparam>
  97.         /// <param name="path">文件路径</param>
  98.         /// <param name="encoding">编码方式</param>
  99.         /// <returns>反序列化得到的对象</returns>
  100.         public static T XmlDeserializeFromFile<T>(string path, Encoding encoding)
  101.         {
  102.             if( string.IsNullOrEmpty(path) )
  103.                 throw new ArgumentNullException("path");
  104.             if( encoding == null )
  105.                 throw new ArgumentNullException("encoding");
  107.             string xml = File.ReadAllText(path, encoding);
  108.             return XmlDeserialize<T>(xml, encoding);
  109.         }
  110.     }
  111. }
复制代码




或许有人会说：我使用XPath从XML读取数据也很简单啊。
我认为这种说法有一个限制条件：只需要从XML中读取少量的数据。
如果要全部读取，用这种方法会写出一大堆的机械代码出来！所以，我非常反感用这种方法从XML中读取全部数据。
类型定义与XML结构的映射

如果是一个新项目，我肯定会毫不犹豫的使用序列化和反序列化的方法来使用XML，然而，有时在维护一个老项目时，面对一堆只有XML却没有与之对应的C#类型时，我们就需要根据XML结构来逆向推导C#类型，然后才能使用序列化和反序列化的方法。逆向推导的过程是麻烦的，不过，类型推导出来之后，后面的事情就简单多了。
为了学会根据XML结构逆向推导类型，我们需要关注一下类型定义与XML结构的映射关系。
注意：有时候我们也会考虑XML结构对于传输量及可阅读性的影响，所以关注一下XML也是有必要的。
这里有一个XML文件，是我从Visual Sutdio的安装目录中找到的：
  1. <DynamicHelp xmlns="http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd"
  2.             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.             xsi:schemaLocation="http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd vsdh.xsd">
  4.     <LinkGroup ID="sites" Title="Venus Sites" Priority="1500">
  5.         <Glyph Collapsed="3" Expanded="4"/>
  6.     </LinkGroup>
  7.     <LinkGroup ID="Venus Private Forums" Title="Venus Private Forums" Priority="1400">
  8.         <Glyph Collapsed="3" Expanded="4"/>
  9.     </LinkGroup>
  10.     <LinkGroup ID="ASP.NET Forums" Title="ASP.NET 1.0 Public Forums" Priority="1200">
  11.         <Glyph Collapsed="3" Expanded="4"/>
  12.     </LinkGroup>
  13.     <Context>
  14.         <Links>
  15.             <LItem URL="http://www.asp.net/venus" LinkGroup="sites">Venus Home Page</LItem>
  16.             <LItem URL="http://www.asp.net" LinkGroup="sites"><LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem></LItem>
  17.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=77"
  18.                     LinkGroup="Venus Private Forums">General Discussions</LItem>
  19.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=83"
  20.                     LinkGroup="Venus Private Forums">Feature Requests</LItem>
  21.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=78"
  22.                     LinkGroup="Venus Private Forums">Bug Reports</LItem>
  23.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=86"
  24.                     LinkGroup="Venus Private Forums">ASP.NET 2.0 Related issues</LItem>
  25.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=11"
  26.                     LinkGroup="ASP.NET Forums">Announcements</LItem>
  27.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=15"
  28.                     LinkGroup="ASP.NET Forums">Getting Started</LItem>
  29.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=18"
  30.                     LinkGroup="ASP.NET Forums">Web Forms</LItem>
  31.         </Links>
  32.     </Context>
  33. </DynamicHelp>
复制代码
怎样用反序列化的方式来读取它的数据呢，我在博客的最后将给出完整的实现代码。
现在，我们还是看一下这个XML有哪些特点吧。
  1. [/code]对于这个节点来说，它包含了三个数据项（属性）：ID，Title，Priority。这样的LinkGroup节点有三个。
  2. 类似的还有Glyph节点。
  3. [code]<LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem>
复制代码
LItem节点除了与LinkGroup有着类似的数据（属性）之外，还包含着一个字符串：<LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem> ，这是另外一种数据的存放方式。
另外，LinkGroup和LItem都允许重复出现，我们可以用数组或者列表（Array，List）来理解它们。
我还发现一些嵌套关系：LinkGroup可以包含Glyph，Context包含着Links，Links又包含了多个LItem。
不管如何嵌套，我发现数据都是包含在一个一个的XML节点中。
如果用专业的单词来描述它们，我们可以将ID，Title，Priority这三个数据项称为 XmlAttribute，LItem，LinkGroup节点称为 XmlElement，”<LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem>“出现的位置可以称为 InnerText。基本上，XML就是由这三类数据组成。
下面我来演示如何使用这三种数据项。
使用 XmlElement

首先，我来定义一个类型：
  1. public class Class1
  2. {
  3.     public int IntValue { get; set; }
  5.     public string StrValue { get; set; }
  6. }
复制代码
下面是序列化与反序列的调用代码：
  1. Class1 c1 = new Class1 { IntValue = 3, StrValue = "Fish Li" };
  2. string xml = XmlHelper.XmlSerialize(c1, Encoding.UTF8);
  3. Console.WriteLine(xml);
  5. Console.WriteLine("---------------------------------------");
  7. Class1 c2 = XmlHelper.XmlDeserialize<Class1>(xml, Encoding.UTF8);
  8. Console.WriteLine("IntValue: " + c2.IntValue.ToString());
  9. Console.WriteLine("StrValue: " + c2.StrValue);
复制代码
运行结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Class1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <<b >IntValue</b>>3</IntValue>
  4.     <<b >StrValue</b>>Fish Li</StrValue>
  5. </Class1>
  6. ---------------------------------------
  7. IntValue: 3
  8. StrValue: Fish Li
复制代码
结果显示，IntValue和StrValue这二个属性生成了XmlElement。
小结：默认情况下（不加任何Attribute），类型中的属性或者字段，都会生成XmlElement。
使用 XmlAttribute

再来定义一个类型：
  1. public class Class2
  2. {
  3.     [XmlAttribute]
  4.     public int IntValue { get; set; }
  6.     [XmlElement]
  7.     public string StrValue { get; set; }
  8. }
复制代码
注意，我在二个属性上增加的不同的Attribute.
下面是序列化与反序列的调用代码：
  1. Class2 c1 = new Class2 { IntValue = 3, StrValue = "Fish Li" };
  2. string xml = XmlHelper.XmlSerialize(c1, Encoding.UTF8);
  3. Console.WriteLine(xml);
  5. Console.WriteLine("---------------------------------------");
  7. Class2 c2 = XmlHelper.XmlDeserialize<Class2>(xml, Encoding.UTF8);
  8. Console.WriteLine("IntValue: " + c2.IntValue.ToString());
  9. Console.WriteLine("StrValue: " + c2.StrValue);
复制代码
运行结果如下（我将结果做了换行处理）：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Class2 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  3.         <b >IntValue</b>="3">
  4.     <<b >StrValue</b>>Fish Li</StrValue>
  5. </Class2>
  6. ---------------------------------------
  7. IntValue: 3
  8. StrValue: Fish Li
复制代码
结果显示：
1. IntValue 生成了XmlAttribute
2. StrValue 生成了XmlElement（和不加[XmlElement]的效果一样，表示就是默认行为）。
小结：如果希望类型中的属性或者字段生成XmlAttribute，需要在类型的成员上用[XmlAttribute]来指出。
使用 InnerText

还是来定义一个类型：
  1. public class Class3
  2. {
  3.     [XmlAttribute]
  4.     public int IntValue { get; set; }
  6.     [XmlText]
  7.     public string StrValue { get; set; }
  8. }
复制代码
注意，我在StrValue上增加的不同的Attribute.
下面是序列化与反序列的调用代码：
  1. Class3 c1 = new Class3 { IntValue = 3, StrValue = "Fish Li" };
  2. string xml = XmlHelper.XmlSerialize(c1, Encoding.UTF8);
  3. Console.WriteLine(xml);
  5. Console.WriteLine("---------------------------------------");
  7. Class3 c2 = XmlHelper.XmlDeserialize<Class3>(xml, Encoding.UTF8);
  8. Console.WriteLine("IntValue: " + c2.IntValue.ToString());
  9. Console.WriteLine("StrValue: " + c2.StrValue);
复制代码
运行结果如下（我将结果做了换行处理）：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Class3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  3.     <b >IntValue</b>="3"><b >Fish Li</b></Class3>
  4. ---------------------------------------
  5. IntValue: 3
  6. StrValue: Fish Li
复制代码
结果符合预期：StrValue属性在增加了[XmlText]之后，生成了一个文本节点（InnerText）
小结：如果希望类型中的属性或者字段生成InnerText，需要在类型的成员上用[XmlText]来指出。
重命名节点名称

看过前面几个示例，大家应该能发现：通过序列化得到的XmlElement和XmlAttribute都与类型的数据成员或者类型同名。然而有时候我们可以希望让属性名与XML的节点名称不一样，那么就要使用【重命名】的功能了，请看以下示例：
  1. [XmlType("c4")]
  2. public class Class4
  3. {
  4.     [XmlAttribute("id")]
  5.     public int IntValue { get; set; }
  7.     [XmlElement("name")]
  8.     public string StrValue { get; set; }
  9. }
复制代码
序列化与反序列的调用代码前面已经多次看到，这里就省略它们了。
运行结果如下（我将结果做了换行处理）：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <<b >c4</b> xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  3.     <b >id</b>="3">
  4.     <<b >name</b>>Fish Li</name>
  5. </c4>
  6. ---------------------------------------
  7. IntValue: 3
  8. StrValue: Fish Li
复制代码
看看输出结果中的红字粗体字，再看看类型定义中的三个Attribute的三个字符串参数，我想你能发现规律的。
小结：XmlAttribute，XmlElement允许接受一个别名用来控制生成节点的名称，类型的重命名用XmlType来实现。
列表和数组的序列化

继续看示例代码：
  1. Class4 c1 = new Class4 { IntValue = 3, StrValue = "Fish Li" };
  2. Class4 c2 = new Class4 { IntValue = 4, StrValue = "http://www.cnblogs.com/fish-li/" };
  4. // 说明：下面二行代码的输出结果是一样的。
  5. List<Class4> list = new List<Class4> { c1, c2 };
  6. //Class4[] list = new Class4[] { c1, c2 };
  8. string xml = XmlHelper.XmlSerialize(list, Encoding.UTF8);
  9. Console.WriteLine(xml);
  11. // 序列化的结果，反序列化一定能读取，所以就不再测试反序列化了。
复制代码
运行结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <<b >ArrayOfC4</b> xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <<b >c4</b> id="3">
  4.         <name>Fish Li</name>
  5.     </c4>
  6.     <<b >c4</b> id="4">
  7.         <name>http://www.cnblogs.com/fish-li/</name>
  8.     </c4>
  9. </ArrayOfC4>
复制代码
现在c4节点已经重复出现了，显然，是我们期待的结果。
不过，ArrayOfC4，这个节点名看起来太奇怪了，能不能给它也重命名呢？
继续看代码，我可以定义一个新的类型：
  1. // 二种Attribute都可以完成同样的功能。
  2. //[XmlType("c4List")]
  3. [XmlRoot("c4List")]
  4. public class Class4List : List<Class4> { }
复制代码
然后，改一下调用代码：
  1. Class4List list = new Class4List { c1, c2 };
复制代码
运行结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <<b >c4List</b> xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <c4 id="3">
  4.         <name>Fish Li</name>
  5.     </c4>
  6.     <c4 id="4">
  7.         <name>http://www.cnblogs.com/fish-li/</name>
  8.     </c4>
  9. </c4List>
复制代码
小结：数组和列表都能直接序列化，如果要重命名根节点名称，需要创建一个新类型来实现。
列表和数组的做为数据成员的序列化

首先，还是定义一个类型：
  1. public class Root
  2. {
  3.     public Class3 Class3 { get; set; }
  5.     public List<Class2> List { get; set; }
  6. }
复制代码
序列化的调用代码：
  1. Class2 c1 = new Class2 { IntValue = 3, StrValue = "Fish Li" };
  2. Class2 c2 = new Class2 { IntValue = 4, StrValue = "http://www.cnblogs.com/fish-li/" };
  4. Class3 c3 = new Class3 { IntValue = 5, StrValue = "Test List" };
  6. Root root = new Root { Class3 = c3, List = new List<Class2> { c1, c2 } };
  8. string xml = XmlHelper.XmlSerialize(root, Encoding.UTF8);
  9. Console.WriteLine(xml);
复制代码
运行结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <Class3 IntValue="5">Test List</Class3>
  4.     <<b >List</b>>
  5.         <<b >Class2</b> IntValue="3">
  6.             <StrValue>Fish Li</StrValue>
  7.         </Class2>
  8.         <<b >Class2</b> IntValue="4">
  9.             <StrValue>http://www.cnblogs.com/fish-li/</StrValue>
  10.         </Class2>
  11.     </List>
  12. </Root>
复制代码
假设这里需要为List和Class2的节点重命名，该怎么办呢？
如果继续使用前面介绍的方法，是行不通的。
下面的代码演示了如何重命名列表节点的名称：
  1. public class Root
  2. {
  3.     public Class3 Class3 { get; set; }
  5.     [XmlArrayItem("c2")]
  6.     [XmlArray("cccccccccccc")]
  7.     public List<Class2> List { get; set; }
  8. }
复制代码
序列化的调用代码与前面完全一样，得到的输出结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <Class3 IntValue="5">Test List</Class3>
  4.     <<b >cccccccccccc</b>>
  5.         <<b >c2</b> IntValue="3">
  6.             <StrValue>Fish Li</StrValue>
  7.         </c2>
  8.         <<b >c2</b> IntValue="4">
  9.             <StrValue>http://www.cnblogs.com/fish-li/</StrValue>
  10.         </c2>
  11.     </cccccccccccc>
  12. </Root>
复制代码
想不想把cccccccccccc节点去掉呢（直接出现c2节点）？
下面的类型定义方式实现了这个想法：
  1. public class Root
  2. {
  3.     public Class3 Class3 { get; set; }
  5.     [XmlElement("c2")]
  6.     public List<Class2> List { get; set; }
  7. }
复制代码
输出结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <Class3 IntValue="5">Test List</Class3>
  4.     <<b >c2</b> IntValue="3">
  5.         <StrValue>Fish Li</StrValue>
  6.     </c2>
  7.     <<b >c2</b> IntValue="4">
  8.         <StrValue>http://www.cnblogs.com/fish-li/</StrValue>
  9.     </c2>
  10. </Root>
复制代码
小结：数组和列表都在序列化时，默认情况下会根据类型中的数据成员名称生成一个节点，列表项会生成子节点，如果要重命名，可以使用[XmlArrayItem]和[XmlArray]来实现。还可以直接用[XmlElement]控制不生成列表的父节点。
类型继承与反序列化

列表元素可以是同一种类型，也可以不是同一种类型（某个类型的派生类）。
例如下面的XML：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <XRoot xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <List>
  4.         <x1 aa="1" bb="2" />
  5.         <x1 aa="3" bb="4" />
  6.         <x2>
  7.             <cc>ccccccccccc</cc>
  8.             <dd>dddddddddddd</dd>
  9.         </x2>
  10.     </List>
  11. </XRoot>
复制代码
想像一下，上面这段XML是通过什么类型得到的呢？
答案如下（注意红色粗体部分）：
  1. public class XBase { }
  3. [XmlType("x1")]
  4. public class X1 : XBase
  5. {
  6.     [XmlAttribute("aa")]
  7.     public int AA { get; set; }
  9.     [XmlAttribute("bb")]
  10.     public int BB { get; set; }
  11. }
  13. [XmlType("x2")]
  14. public class X2 : XBase
  15. {
  16.     [XmlElement("cc")]
  17.     public string CC { get; set; }
  19.     [XmlElement("dd")]
  20.     public string DD { get; set; }
  21. }
  23. public class XRoot
  24. {
  25.     [<b >XmlArrayItem</b>(typeof(X1)),
  26.     <b >XmlArrayItem</b>(typeof(X2))]
  27.     public List<XBase> List { get; set; }
  28. }
复制代码
序列化代码：
  1. X1 x1a = new X1 { AA = 1, BB = 2 };
  2. X1 x1b = new X1 { AA = 3, BB = 4 };
  3. X2 x2 = new X2 { CC = "ccccccccccc", DD = "dddddddddddd" };
  4. XRoot root = new XRoot { List = new List<XBase> { x1a, x1b, x2 } };
  6. string xml = XmlHelper.XmlSerialize(root, Encoding.UTF8);
  7. Console.WriteLine(xml);
复制代码
小结：同时为列表成员指定多个[XmlArrayItem(typeof(XXX))]可实现多种派生类型混在一起输出。
反序列化的实战演练

接下来，我们将根据前面介绍的知识点，用反序列化的方法来解析本文开头处贴出的那段XML：
  1. <DynamicHelp xmlns="http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd"
  2.             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.             xsi:schemaLocation="http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd vsdh.xsd">
  4.     <LinkGroup ID="sites" Title="Venus Sites" Priority="1500">
  5.         <Glyph Collapsed="3" Expanded="4"/>
  6.     </LinkGroup>
  7.     <LinkGroup ID="Venus Private Forums" Title="Venus Private Forums" Priority="1400">
  8.         <Glyph Collapsed="3" Expanded="4"/>
  9.     </LinkGroup>
  10.     <LinkGroup ID="ASP.NET Forums" Title="ASP.NET 1.0 Public Forums" Priority="1200">
  11.         <Glyph Collapsed="3" Expanded="4"/>
  12.     </LinkGroup>
  13.     <Context>
  14.         <Links>
  15.             <LItem URL="http://www.asp.net/venus" LinkGroup="sites">Venus Home Page</LItem>
  16.             <LItem URL="http://www.asp.net" LinkGroup="sites"><LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem></LItem>
  17.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=77"
  18.                     LinkGroup="Venus Private Forums">General Discussions</LItem>
  19.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=83"
  20.                     LinkGroup="Venus Private Forums">Feature Requests</LItem>
  21.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=78"
  22.                     LinkGroup="Venus Private Forums">Bug Reports</LItem>
  23.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=86"
  24.                     LinkGroup="Venus Private Forums">ASP.NET 2.0 Related issues</LItem>
  25.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=11"
  26.                     LinkGroup="ASP.NET Forums">Announcements</LItem>
  27.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=15"
  28.                     LinkGroup="ASP.NET Forums">Getting Started</LItem>
  29.             <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=18"
  30.                     LinkGroup="ASP.NET Forums">Web Forms</LItem>
  31.         </Links>
  32.     </Context>
  33. </DynamicHelp>
复制代码
那段XML的根元素是DynamicHelp，因此，我们需要定义一个类型，类名为DynamicHelp。
再观察那段XML，它应该包含一个LinkGroup列表，和一个Context属性，所以可以这样定义这三个类型：
  1. public class DynamicHelp
  2. {
  3.     [XmlElement]
  4.     public List<LinkGroup> Groups { get; set; }
  6.     public Context Context { get; set; }
  7. }
  9. public class LinkGroup { }
  11. public class Context { }
复制代码
再来看LinkGroup，它包含三个数据成员，以及一个子节点：Glyph，因此可以这样定义它们：
  1. public class LinkGroup
  2. {
  3.     [XmlAttribute]
  4.     public string ID { get; set; }
  5.     [XmlAttribute]
  6.     public string Title { get; set; }
  7.     [XmlAttribute]
  8.     public int Priority { get; set; }
  10.     public Glyph Glyph { get; set; }
  11. }
  13. public class Glyph
  14. {
  15.     [XmlAttribute]
  16.     public int Collapsed { get; set; }
  17.     [XmlAttribute]
  18.     public int Expanded { get; set; }
  19. }
复制代码
LItem节点也简单，它就包含了URL，LinkGroup和一个文本节点，因此可以这样定义它：
  1. public class LItem
  2. {
  3.     [XmlAttribute]
  4.     public string URL { get; set; }
  5.     [XmlAttribute]
  6.     public string LinkGroup { get; set; }
  8.     [XmlText]
  9.     public string Title { get; set; }
  10. }
复制代码
Context节点也不复杂，就只包含了一个LItem列表，因此可以这样定义它：
  1. public class Context
  2. {
  3.     public List<LItem> Links { get; set; }
  4. }
复制代码
好了，类型都定义好了，再来试试反序列化：
  1. DynamicHelp help = XmlHelper.XmlDeserializeFromFile<DynamicHelp>("Links.xml", Encoding.UTF8);
  3. foreach( LinkGroup group in help.Groups )
  4.     Console.WriteLine("ID: {0}, Title: {1}, Priority: {2}, Collapsed: {3}, Expanded: {4}",
  5.         group.ID, group.Title, group.Priority, group.Glyph.Collapsed, group.Glyph.Expanded);
  7. foreach( LItem item in help.Context.Links )
  8.     Console.WriteLine("URL: {0}, LinkGroup: {1}, Title: {2}",
  9.         item.URL.Substring(0, 15), item.LinkGroup, item.Title);
复制代码
屏幕显示：
  1. 未处理的异常:  System.InvalidOperationException: XML 文档(4, 2)中有错误。
  2. ---> System.InvalidOperationException: 不应有
  3. <DynamicHelp xmlns='http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd'>。
复制代码
哦，抛异常了。
别急，看看异常说什么。
好像是在说命名空间不能识别。
根据异常的描述，我还要修改一下DynamicHelp的定义，改成这样：
  1. [XmlRoot(Namespace = "http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd")]
  2. public class DynamicHelp
复制代码
再次运行，结果如下：
  1. ID: sites, Title: Venus Sites, Priority: 1500, Collapsed: 3, Expanded: 4ID: Venus Private Forums, Title: Venus Private Forums, Priority: 1400, Collapsed: 3, Expanded: 4ID: ASP.NET Forums, Title: ASP.NET 1.0 Public Forums, Priority: 1200, Collapsed: 3, Expanded: 4URL: http://www.asp., LinkGroup: sites, Title: Venus Home PageURL: http://www.asp., LinkGroup: sites, Title: <LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem>URL: http://www.asp., LinkGroup: Venus Private Forums, Title: General DiscussionsURL: http://www.asp., LinkGroup: Venus Private Forums, Title: Feature RequestsURL: http://www.asp., LinkGroup: Venus Private Forums, Title: Bug ReportsURL: http://www.asp., LinkGroup: Venus Private Forums, Title: ASP.NET 2.0 Related issuesURL: http://www.asp., LinkGroup: ASP.NET Forums, Title: AnnouncementsURL: http://www.asp., LinkGroup: ASP.NET Forums, Title: Getting StartedURL: http://www.asp., LinkGroup: ASP.NET Forums, Title: Web Forms
复制代码
小结：根据XML结构推导类型时，要保证类型的层次结构与XML匹配，数据的存放方式可以通过[XmlElement]，[XmlAttribute]，[XmlText]方式来指出。
反序列化的使用总结

如果XML是由类型序列化得到那的，那么反序列化的调用代码是很简单的，
反之，如果要面对一个没有类型的XML，就需要我们先设计一个（或者一些）类型出来，
这是一个逆向推导的过程，请参考以下步骤：
1. 首先要分析整个XML结构，定义与之匹配的类型，
2. 如果XML结构有嵌套层次，则需要定义多个类型与之匹配，
3. 定义具体类型（一个层级下的XML结构）时，请参考以下表格。
XML形式处理方法补充说明
XmlElement定义一个属性属性名与节点名字匹配
XmlAttribute[XmlAttribute] 加到属性上
InnerText[XmlText] 加到属性上一个类型只能使用一次
节点重命名根节点：[XmlType("testClass")]
元素节点：[XmlElement("name")]
属性节点：[XmlAttribute("id")]
列表子元素节点：[XmlArrayItem("Detail")]
列表元素自身：[XmlArray("Items")]
排除不需要序列化的成员

默认情况下，类型的所有公开的数据成员（属性，字段）在序列化时都会被输出，如果希望排除某些成员，可以用[XmlIgnore]来指出，例如：
  1. public class TestIgnore
  2. {
  3.     [XmlIgnore]    // 这个属性将不会参与序列化
  4.     public int IntValue { get; set; }
  6.     public string StrValue { get; set; }
  8.     public string Url;
  9. }
复制代码
序列化调用代码：
  1. TestIgnore c1 = new TestIgnore { IntValue = 3, StrValue = "Fish Li" };
  2. c1.Url = "http://www.cnblogs.com/fish-li/";
  4. string xml = XmlHelper.XmlSerialize(c1, Encoding.UTF8);
  5. Console.WriteLine(xml);
复制代码
输出结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <TestIgnore xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <Url>http://www.cnblogs.com/fish-li/</Url>
  4.     <StrValue>Fish Li</StrValue>
  5. </TestIgnore>
复制代码
强制指定成员的序列化顺序

前面的示例很奇怪，我明明先定义的StrValue，后定义的Url，可是在输出时的顺序并是我期望的。
如果你希望控制序列化的输出顺序，可以参考下面的示例代码（注意红色粗体文字）：
  1. public class TestIgnore
  2. {
  3.     [XmlIgnore]    // 这个属性将不会参与序列化
  4.     public int IntValue { get; set; }
  6.     [XmlElement(<b >Order</b> = 1)]
  7.     public string StrValue { get; set; }
  9.     [XmlElement(<b >Order</b> = 2)]
  10.     public string Url;
  11. }
复制代码
最终的输出结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <TestIgnore xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <StrValue>Fish Li</StrValue>
  4.     <Url>http://www.cnblogs.com/fish-li/</Url>
  5. </TestIgnore>
复制代码
自定义序列化行为

由于种种原因，可能需要我们自己控制序列化和反序列化的过程，对于这种需求， .net framework也是支持的，下面我来演示如何这个过程。
假如我现在有这样的类型定义：
  1. public class TestClass
  2. {
  3.     public string StrValue { get; set; }
  5.     public List<int> List { get; set; }
  6. }
  8. public class ClassB1
  9. {
  10.     public TestClass Test { get; set; }
  11. }
复制代码
测试代码：
  1. TestClass test = new TestClass { StrValue = "Fish Li", List = new List<int> { 1, 2, 3, 4, 5 } };
  2. ClassB1 b1 = new ClassB1 { Test = test };
  4. string xml = XmlHelper.XmlSerialize(b1, Encoding.UTF8);
  5. Console.WriteLine(xml);
  7. Console.WriteLine("-----------------------------------------------------");
  9. ClassB1 b2 = XmlHelper.XmlDeserialize<ClassB1>(xml, Encoding.UTF8);
  10. Console.WriteLine("StrValue: " + b2.Test.StrValue);
  11. foreach( int n in b2.Test.List )
  12.     Console.WriteLine(n);
复制代码
此时程序的输出结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <ClassB1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <Test>
  4.         <StrValue>Fish Li</StrValue>
  5.         <List>
  6.             <int>1</int>
  7.             <int>2</int>
  8.             <int>3</int>
  9.             <int>4</int>
  10.             <int>5</int>
  11.         </List>
  12.     </Test>
  13. </ClassB1>
  14. -----------------------------------------------------
  15. StrValue: Fish Li
  16. 1
  17. 2
  18. 3
  19. 4
  20. 5
复制代码
现在我可能会想：TestClass这个类太简单了，但它输出的XML长度复杂了点，能不能再短小一点，让网络传输地更快呢？
在这里，我想到了自定义序列化行为来实现，请看下面对TestClass的重新定义。
  1. public class TestClass : IXmlSerializable
  2. {
  3.     public string StrValue { get; set; }
  5.     public List<int> List { get; set; }
  7.     public System.Xml.Schema.XmlSchema GetSchema()
  8.     {
  9.         return null;
  10.     }
  12.     public void ReadXml(XmlReader reader)
  13.     {
  14.         StrValue = reader.GetAttribute("s");
  16.         string numbers = reader.ReadString();
  17.         if( string.IsNullOrEmpty(numbers) == false )
  18.             List = (from s in numbers.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
  19.                     let n = int.Parse(s)
  20.                     select n).ToList();
  21.     }
  23.     public void WriteXml(XmlWriter writer)
  24.     {
  25.         writer.WriteAttributeString("s", StrValue);
  26.         writer.WriteString(string.Join(",", List.ConvertAll<string>(x => x.ToString()).ToArray()));
  27.     }
  28. }
复制代码
继续使用前面的测试代码，现在的输出结果如下：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <ClassB1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <Test s="Fish Li">1,2,3,4,5</Test>
  4. </ClassB1>
  5. -----------------------------------------------------
  6. StrValue: Fish Li
  7. 1
  8. 2
  9. 3
  10. 4
  11. 5
复制代码
很明显，现在的序列化结果要比以前的结果小很多。
而且，测试代码中的反序列化的显示也表明，我们仍然可以通过反序列化来读取它。
序列化去掉XML命名空间及声明头

在前面的示例中，我们会发现有时很简单的XML在加了命名空间及声明头以后，结构变复杂了，内容也变长了。有些人看到它们可能总是感觉非常别扭，例如：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <ClassB1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <Test s="Fish Li">1,2,3,4,5</Test>
  4. </ClassB1>
复制代码
能不能只显示成下面这样呢？
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <ClassB1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.     <Test s="Fish Li">1,2,3,4,5</Test>
  4. </ClassB1>
复制代码
答案是肯定的，按下面的方法修改本文的示例代码：
  1. private static void XmlSerializeInternal(Stream stream, object o, Encoding encoding)
  2. {
  3.     if( o == null )
  4.         throw new ArgumentNullException("o");
  5.     if( encoding == null )
  6.         throw new ArgumentNullException("encoding");
  8.     XmlSerializer serializer = new XmlSerializer(o.GetType());
  10.     XmlWriterSettings settings = new XmlWriterSettings();
  11.     settings.Indent = true;
  12.     settings.NewLineChars = "\r\n";
  13.     settings.Encoding = encoding;
  14.     settings.IndentChars = "    ";
  16.     // 不生成声明头
  17.     settings.OmitXmlDeclaration = true;
  19.     // 强制指定命名空间，覆盖默认的命名空间。
  20.     XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
  21.     namespaces.Add(string.Empty, string.Empty);
  23.     using( XmlWriter writer = XmlWriter.Create(stream, settings) ) {
  24.         serializer.Serialize(writer, o, namespaces);
  25.         writer.Close();
  26.     }
  27. }
复制代码
说明：去掉XML命名空间及声明头不影响反序列化。
XML的使用建议

在服务端，C#代码中：
1. 建议不用使用低级别的XML API来使用XML，除非你是在设计框架或者通用类库。
2. 建议使用序列化、反序列化的方法来生成或者读取XML
3. 当需要考虑使用XML时，先不要想着XML结构，先应该定义好数据类型。
4. 列表节点不要使用[XmlElement]，它会让所有子节点【升级】，显得结构混乱。
5. 如果希望序列化的XML长度小一点，可以采用[XmlAttribute]，或者指定一个更短小的别名。
6. 不要在一个列表中输出不同的数据类型，这样的XML结构的可读性不好。
7. 尽量使用UTF-8编码，不要使用GB2312编码。
在客户端，JavaScript代码中，我不建议使用XML，而是建议使用JSON来代替XML，因为：
1. XML文本的长度比JSON要长，会占用更多的网络传输时间（毕竟数据保存在服务端，所以传输是免不了的）
2. 在JavaScritp中使用XML比较麻烦（还有浏览器的兼容问题），反而各种浏览器对JSON有非常好的支持。

点击此处下载示例代码
如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】按钮。
如果，您希望更容易地发现我的新博客，不妨点击一下右下角的【关注 Fish Li】。
因为，我的写作热情也离不开您的肯定支持。
感谢您的阅读，如果您对我的博客所讲述的内容有兴趣，请继续关注我的后续博客，我是Fish Li 。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
秦晓曼
2025-5-29 16:34:45

0

粉丝关注

9

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫