在.net中序列化读写xml方法的总结
2015-01-24 05:18
453 查看
在.net中序列化读写xml方法的总结
阅读目录开始
最简单的使用XML的方法
类型定义与XML结构的映射
使用 XmlElement
使用 XmlAttribute
使用 InnerText
重命名节点名称
列表和数组的序列化
列表和数组的做为数据成员的序列化
类型继承与反序列化
反序列化的实战演练
反序列化的使用总结
排除不需要序列化的成员
强制指定成员的序列化顺序
自定义序列化行为
序列化去掉XML命名空间及声明头
XML的使用建议
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. 首先要创建或者得到一个数据对象 Order order = GetOrderById(123); // 2. 用序列化的方法生成XML string xml = XmlHelper.XmlSerialize(order, Encoding.UTF8); // 3. 从XML读取数据并生成对象 Order order2 = XmlHelper.XmlDeserialize<Order>(xml, Encoding.UTF8);
就是这么简单的事情,XML结构是什么样的,我根本不用关心, 我只关心数据是否能保存以及下次是否能将它们读取出来。
说明:XmlHelper是一个工具类,全部源代码如下:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Xml.Serialization; using System.IO; using System.Xml; // 此处代码来源于博客【在.net中读写config文件的各种方法】的示例代码 // /article/4764164.html namespace MyMVC { public static class XmlHelper { private static void XmlSerializeInternal(Stream stream, object o, Encoding encoding) { if( o == null ) throw new ArgumentNullException("o"); if( encoding == null ) throw new ArgumentNullException("encoding"); XmlSerializer serializer = new XmlSerializer(o.GetType()); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.NewLineChars = "\r\n"; settings.Encoding = encoding; settings.IndentChars = " "; using( XmlWriter writer = XmlWriter.Create(stream, settings) ) { serializer.Serialize(writer, o); writer.Close(); } } /// <summary> /// 将一个对象序列化为XML字符串 /// </summary> /// <param name="o">要序列化的对象</param> /// <param name="encoding">编码方式</param> /// <returns>序列化产生的XML字符串</returns> public static string XmlSerialize(object o, Encoding encoding) { using( MemoryStream stream = new MemoryStream() ) { XmlSerializeInternal(stream, o, encoding); stream.Position = 0; using( StreamReader reader = new StreamReader(stream, encoding) ) { return reader.ReadToEnd(); } } } /// <summary> /// 将一个对象按XML序列化的方式写入到一个文件 /// </summary> /// <param name="o">要序列化的对象</param> /// <param name="path">保存文件路径</param> /// <param name="encoding">编码方式</param> public static void XmlSerializeToFile(object o, string path, Encoding encoding) { if( string.IsNullOrEmpty(path) ) throw new ArgumentNullException("path"); using( FileStream file = new FileStream(path, FileMode.Create, FileAccess.Write) ) { XmlSerializeInternal(file, o, encoding); } } /// <summary> /// 从XML字符串中反序列化对象 /// </summary> /// <typeparam name="T">结果对象类型</typeparam> /// <param name="s">包含对象的XML字符串</param> /// <param name="encoding">编码方式</param> /// <returns>反序列化得到的对象</returns> public static T XmlDeserialize<T>(string s, Encoding encoding) { if( string.IsNullOrEmpty(s) ) throw new ArgumentNullException("s"); if( encoding == null ) throw new ArgumentNullException("encoding"); XmlSerializer mySerializer = new XmlSerializer(typeof(T)); using( MemoryStream ms = new MemoryStream(encoding.GetBytes(s)) ) { using( StreamReader sr = new StreamReader(ms, encoding) ) { return (T)mySerializer.Deserialize(sr); } } } /// <summary> /// 读入一个文件,并按XML的方式反序列化对象。 /// </summary> /// <typeparam name="T">结果对象类型</typeparam> /// <param name="path">文件路径</param> /// <param name="encoding">编码方式</param> /// <returns>反序列化得到的对象</returns> public static T XmlDeserializeFromFile<T>(string path, Encoding encoding) { if( string.IsNullOrEmpty(path) ) throw new ArgumentNullException("path"); if( encoding == null ) throw new ArgumentNullException("encoding"); string xml = File.ReadAllText(path, encoding); return XmlDeserialize<T>(xml, encoding); } } }
或许有人会说:我使用XPath从XML读取数据也很简单啊。 我认为这种说法有一个限制条件:只需要从XML中读取少量的数据。 如果要全部读取,用这种方法会写出一大堆的机械代码出来! 所以,我非常反感用这种方法从XML中读取全部数据。
回到顶部
类型定义与XML结构的映射
如果是一个新项目,我肯定会毫不犹豫的使用序列化和反序列化的方法来使用XML, 然而,有时在维护一个老项目时,面对一堆只有XML却没有与之对应的C#类型时, 我们就需要根据XML结构来逆向推导C#类型,然后才能使用序列化和反序列化的方法。 逆向推导的过程是麻烦的,不过,类型推导出来之后,后面的事情就简单多了。为了学会根据XML结构逆向推导类型,我们需要关注一下类型定义与XML结构的映射关系。 注意:有时候我们也会考虑XML结构对于传输量及可阅读性的影响,所以关注一下XML也是有必要的。
这里有一个XML文件,是我从Visual Sutdio的安装目录中找到的:
<DynamicHelp xmlns="http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd vsdh.xsd"> <LinkGroup ID="sites" Title="Venus Sites" Priority="1500"> <Glyph Collapsed="3" Expanded="4"/> </LinkGroup> <LinkGroup ID="Venus Private Forums" Title="Venus Private Forums" Priority="1400"> <Glyph Collapsed="3" Expanded="4"/> </LinkGroup> <LinkGroup ID="ASP.NET Forums" Title="ASP.NET 1.0 Public Forums" Priority="1200"> <Glyph Collapsed="3" Expanded="4"/> </LinkGroup> <Context> <Links> <LItem URL="http://www.asp.net/venus" LinkGroup="sites">Venus Home Page</LItem> <LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=77" LinkGroup="Venus Private Forums">General Discussions</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=83" LinkGroup="Venus Private Forums">Feature Requests</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=78" LinkGroup="Venus Private Forums">Bug Reports</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=86" LinkGroup="Venus Private Forums">ASP.NET 2.0 Related issues</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=11" LinkGroup="ASP.NET Forums">Announcements</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=15" LinkGroup="ASP.NET Forums">Getting Started</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=18" LinkGroup="ASP.NET Forums">Web Forms</LItem> </Links> </Context> </DynamicHelp>
怎样用反序列化的方式来读取它的数据呢,我在博客的最后将给出完整的实现代码。 现在,我们还是看一下这个XML有哪些特点吧。
<LinkGroup ID="sites" Title="Venus Sites" Priority="1500">
对于这个节点来说,它包含了三个数据项(属性):ID,Title,Priority。 这样的LinkGroup节点有三个。 类似的还有Glyph节点。
<LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem>
LItem节点除了与LinkGroup有着类似的数据(属性)之外,还包含着一个字符串:ASP.NET Home Page , 这是另外一种数据的存放方式。
另外,LinkGroup和LItem都允许重复出现,我们可以用数组或者列表(Array,List)来理解它们。
我还发现一些嵌套关系:LinkGroup可以包含Glyph,Context包含着Links,Links又包含了多个LItem。 不管如何嵌套,我发现数据都是包含在一个一个的XML节点中。
如果用专业的单词来描述它们,我们可以将ID,Title,Priority这三个数据项称为 XmlAttribute, LItem,LinkGroup节点称为 XmlElement,”ASP.NET Home Page“出现的位置可以称为 InnerText。 基本上,XML就是由这三类数据组成。
下面我来演示如何使用这三种数据项。
回到顶部
使用 XmlElement
首先,我来定义一个类型:public class Class1 { public int IntValue { get; set; } public string StrValue { get; set; } }
下面是序列化与反序列的调用代码:
Class1 c1 = new Class1 { IntValue = 3, StrValue = "Fish Li" }; string xml = XmlHelper.XmlSerialize(c1, Encoding.UTF8); Console.WriteLine(xml); Console.WriteLine("---------------------------------------"); Class1 c2 = XmlHelper.XmlDeserialize<Class1>(xml, Encoding.UTF8); Console.WriteLine("IntValue: " + c2.IntValue.ToString()); Console.WriteLine("StrValue: " + c2.StrValue);
运行结果如下:
<?xml version="1.0" encoding="utf-8"?> <Class1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <IntValue>3</IntValue> <StrValue>Fish Li</StrValue> </Class1> --------------------------------------- IntValue: 3 StrValue: Fish Li
结果显示,IntValue和StrValue这二个属性生成了XmlElement。
小结:默认情况下(不加任何Attribute),类型中的属性或者字段,都会生成XmlElement。
回到顶部
使用 XmlAttribute
再来定义一个类型:public class Class2 { [XmlAttribute] public int IntValue { get; set; } [XmlElement] public string StrValue { get; set; } }
注意,我在二个属性上增加的不同的Attribute.
下面是序列化与反序列的调用代码:
Class2 c1 = new Class2 { IntValue = 3, StrValue = "Fish Li" }; string xml = XmlHelper.XmlSerialize(c1, Encoding.UTF8); Console.WriteLine(xml); Console.WriteLine("---------------------------------------"); Class2 c2 = XmlHelper.XmlDeserialize<Class2>(xml, Encoding.UTF8); Console.WriteLine("IntValue: " + c2.IntValue.ToString()); Console.WriteLine("StrValue: " + c2.StrValue);
运行结果如下(我将结果做了换行处理):
<?xml version="1.0" encoding="utf-8"?> <Class2 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" IntValue="3"> <StrValue>Fish Li</StrValue> </Class2> --------------------------------------- IntValue: 3 StrValue: Fish Li
结果显示: 1. IntValue 生成了XmlAttribute 2. StrValue 生成了XmlElement(和不加[XmlElement]的效果一样,表示就是默认行为)。
小结:如果希望类型中的属性或者字段生成XmlAttribute,需要在类型的成员上用[XmlAttribute]来指出。
回到顶部
使用 InnerText
还是来定义一个类型:public class Class3 { [XmlAttribute] public int IntValue { get; set; } [XmlText] public string StrValue { get; set; } }
注意,我在StrValue上增加的不同的Attribute.
下面是序列化与反序列的调用代码:
Class3 c1 = new Class3 { IntValue = 3, StrValue = "Fish Li" }; string xml = XmlHelper.XmlSerialize(c1, Encoding.UTF8); Console.WriteLine(xml); Console.WriteLine("---------------------------------------"); Class3 c2 = XmlHelper.XmlDeserialize<Class3>(xml, Encoding.UTF8); Console.WriteLine("IntValue: " + c2.IntValue.ToString()); Console.WriteLine("StrValue: " + c2.StrValue);
运行结果如下(我将结果做了换行处理):
<?xml version="1.0" encoding="utf-8"?> <Class3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" IntValue="3">Fish Li</Class3> --------------------------------------- IntValue: 3 StrValue: Fish Li
结果符合预期:StrValue属性在增加了[XmlText]之后,生成了一个文本节点(InnerText)
小结:如果希望类型中的属性或者字段生成InnerText,需要在类型的成员上用[XmlText]来指出。
回到顶部
重命名节点名称
看过前面几个示例,大家应该能发现:通过序列化得到的XmlElement和XmlAttribute都与类型的数据成员或者类型同名。 然而有时候我们可以希望让属性名与XML的节点名称不一样,那么就要使用【重命名】的功能了,请看以下示例:[XmlType("c4")] public class Class4 { [XmlAttribute("id")] public int IntValue { get; set; } [XmlElement("name")] public string StrValue { get; set; } }
序列化与反序列的调用代码前面已经多次看到,这里就省略它们了。 运行结果如下(我将结果做了换行处理):
<?xml version="1.0" encoding="utf-8"?> <c4 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" id="3"> <name>Fish Li</name> </c4> --------------------------------------- IntValue: 3 StrValue: Fish Li
看看输出结果中的红字粗体字,再看看类型定义中的三个Attribute的三个字符串参数,我想你能发现规律的。
小结:XmlAttribute,XmlElement允许接受一个别名用来控制生成节点的名称,类型的重命名用XmlType来实现。
回到顶部
列表和数组的序列化
继续看示例代码:Class4 c1 = new Class4 { IntValue = 3, StrValue = "Fish Li" }; Class4 c2 = new Class4 { IntValue = 4, StrValue = "http://www.cnblogs.com/fish-li/" }; // 说明:下面二行代码的输出结果是一样的。 List<Class4> list = new List<Class4> { c1, c2 }; //Class4[] list = new Class4[] { c1, c2 }; string xml = XmlHelper.XmlSerialize(list, Encoding.UTF8); Console.WriteLine(xml); // 序列化的结果,反序列化一定能读取,所以就不再测试反序列化了。
运行结果如下:
<?xml version="1.0" encoding="utf-8"?> <ArrayOfC4 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <c4 id="3"> <name>Fish Li</name> </c4> <c4 id="4"> <name>http://www.cnblogs.com/fish-li/</name> </c4> </ArrayOfC4>
现在c4节点已经重复出现了,显然,是我们期待的结果。
不过,ArrayOfC4,这个节点名看起来太奇怪了,能不能给它也重命名呢? 继续看代码,我可以定义一个新的类型:
// 二种Attribute都可以完成同样的功能。 //[XmlType("c4List")] [XmlRoot("c4List")] public class Class4List : List<Class4> { }
然后,改一下调用代码:
Class4List list = new Class4List { c1, c2 };
运行结果如下:
<?xml version="1.0" encoding="utf-8"?> <c4List xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <c4 id="3"> <name>Fish Li</name> </c4> <c4 id="4"> <name>http://www.cnblogs.com/fish-li/</name> </c4> </c4List>
小结:数组和列表都能直接序列化,如果要重命名根节点名称,需要创建一个新类型来实现。
回到顶部
列表和数组的做为数据成员的序列化
首先,还是定义一个类型:public class Root { public Class3 Class3 { get; set; } public List<Class2> List { get; set; } }
序列化的调用代码:
Class2 c1 = new Class2 { IntValue = 3, StrValue = "Fish Li" }; Class2 c2 = new Class2 { IntValue = 4, StrValue = "http://www.cnblogs.com/fish-li/" }; Class3 c3 = new Class3 { IntValue = 5, StrValue = "Test List" }; Root root = new Root { Class3 = c3, List = new List<Class2> { c1, c2 } }; string xml = XmlHelper.XmlSerialize(root, Encoding.UTF8); Console.WriteLine(xml);
运行结果如下:
<?xml version="1.0" encoding="utf-8"?> <Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Class3 IntValue="5">Test List</Class3> <List> <Class2 IntValue="3"> <StrValue>Fish Li</StrValue> </Class2> <Class2 IntValue="4"> <StrValue>http://www.cnblogs.com/fish-li/</StrValue> </Class2> </List> </Root>
假设这里需要为List和Class2的节点重命名,该怎么办呢? 如果继续使用前面介绍的方法,是行不通的。
下面的代码演示了如何重命名列表节点的名称:
public class Root { public Class3 Class3 { get; set; } [XmlArrayItem("c2")] [XmlArray("cccccccccccc")] public List<Class2> List { get; set; } }
序列化的调用代码与前面完全一样,得到的输出结果如下:
<?xml version="1.0" encoding="utf-8"?> <Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Class3 IntValue="5">Test List</Class3> <cccccccccccc> <c2 IntValue="3"> <StrValue>Fish Li</StrValue> </c2> <c2 IntValue="4"> <StrValue>http://www.cnblogs.com/fish-li/</StrValue> </c2> </cccccccccccc> </Root>
想不想把cccccccccccc节点去掉呢(直接出现c2节点)? 下面的类型定义方式实现了这个想法:
public class Root { public Class3 Class3 { get; set; } [XmlElement("c2")] public List<Class2> List { get; set; } }
输出结果如下:
<?xml version="1.0" encoding="utf-8"?> <Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Class3 IntValue="5">Test List</Class3> <c2 IntValue="3"> <StrValue>Fish Li</StrValue> </c2> <c2 IntValue="4"> <StrValue>http://www.cnblogs.com/fish-li/</StrValue> </c2> </Root>
小结:数组和列表都在序列化时,默认情况下会根据类型中的数据成员名称生成一个节点, 列表项会生成子节点,如果要重命名,可以使用[XmlArrayItem]和[XmlArray]来实现。 还可以直接用[XmlElement]控制不生成列表的父节点。
回到顶部
类型继承与反序列化
列表元素可以是同一种类型,也可以不是同一种类型(某个类型的派生类)。 例如下面的XML:<?xml version="1.0" encoding="utf-8"?> <XRoot xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <List> <x1 aa="1" bb="2" /> <x1 aa="3" bb="4" /> <x2> <cc>ccccccccccc</cc> <dd>dddddddddddd</dd> </x2> </List> </XRoot>
想像一下,上面这段XML是通过什么类型得到的呢?
答案如下(注意红色粗体部分):
public class XBase { } [XmlType("x1")] public class X1 : XBase { [XmlAttribute("aa")] public int AA { get; set; } [XmlAttribute("bb")] public int BB { get; set; } } [XmlType("x2")] public class X2 : XBase { [XmlElement("cc")] public string CC { get; set; } [XmlElement("dd")] public string DD { get; set; } } public class XRoot { [XmlArrayItem(typeof(X1)), XmlArrayItem(typeof(X2))] public List<XBase> List { get; set; } }
序列化代码:
X1 x1a = new X1 { AA = 1, BB = 2 }; X1 x1b = new X1 { AA = 3, BB = 4 }; X2 x2 = new X2 { CC = "ccccccccccc", DD = "dddddddddddd" }; XRoot root = new XRoot { List = new List<XBase> { x1a, x1b, x2 } }; string xml = XmlHelper.XmlSerialize(root, Encoding.UTF8); Console.WriteLine(xml);
小结:同时为列表成员指定多个[XmlArrayItem(typeof(XXX))]可实现多种派生类型混在一起输出。
回到顶部
反序列化的实战演练
接下来,我们将根据前面介绍的知识点,用反序列化的方法来解析本文开头处贴出的那段XML:<DynamicHelp xmlns="http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd vsdh.xsd"> <LinkGroup ID="sites" Title="Venus Sites" Priority="1500"> <Glyph Collapsed="3" Expanded="4"/> </LinkGroup> <LinkGroup ID="Venus Private Forums" Title="Venus Private Forums" Priority="1400"> <Glyph Collapsed="3" Expanded="4"/> </LinkGroup> <LinkGroup ID="ASP.NET Forums" Title="ASP.NET 1.0 Public Forums" Priority="1200"> <Glyph Collapsed="3" Expanded="4"/> </LinkGroup> <Context> <Links> <LItem URL="http://www.asp.net/venus" LinkGroup="sites">Venus Home Page</LItem> <LItem URL="http://www.asp.net" LinkGroup="sites">ASP.NET Home Page</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=77" LinkGroup="Venus Private Forums">General Discussions</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=83" LinkGroup="Venus Private Forums">Feature Requests</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=78" LinkGroup="Venus Private Forums">Bug Reports</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=86" LinkGroup="Venus Private Forums">ASP.NET 2.0 Related issues</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=11" LinkGroup="ASP.NET Forums">Announcements</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=15" LinkGroup="ASP.NET Forums">Getting Started</LItem> <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&ForumID=18" LinkGroup="ASP.NET Forums">Web Forms</LItem> </Links> </Context> </DynamicHelp>
那段XML的根元素是DynamicHelp,因此,我们需要定义一个类型,类名为DynamicHelp。 再观察那段XML,它应该包含一个LinkGroup列表,和一个Context属性,所以可以这样定义这三个类型:
public class DynamicHelp { [XmlElement] public List<LinkGroup> Groups { get; set; } public Context Context { get; set; } } public class LinkGroup { } public class Context { }
再来看LinkGroup,它包含三个数据成员,以及一个子节点:Glyph,因此可以这样定义它们:
public class LinkGroup { [XmlAttribute] public string ID { get; set; } [XmlAttribute] public string Title { get; set; } [XmlAttribute] public int Priority { get; set; } public Glyph Glyph { get; set; } } public class Glyph { [XmlAttribute] public int Collapsed { get; set; } [XmlAttribute] public int Expanded { get; set; } }
LItem节点也简单,它就包含了URL,LinkGroup和一个文本节点,因此可以这样定义它:
public class LItem { [XmlAttribute] public string URL { get; set; } [XmlAttribute] public string LinkGroup { get; set; } [XmlText] public string Title { get; set; } }
Context节点也不复杂,就只包含了一个LItem列表,因此可以这样定义它:
public class Context { public List<LItem> Links { get; set; } }
好了,类型都定义好了,再来试试反序列化:
DynamicHelp help = XmlHelper.XmlDeserializeFromFile<DynamicHelp>("Links.xml", Encoding.UTF8); foreach( LinkGroup group in help.Groups ) Console.WriteLine("ID: {0}, Title: {1}, Priority: {2}, Collapsed: {3}, Expanded: {4}", group.ID, group.Title, group.Priority, group.Glyph.Collapsed, group.Glyph.Expanded); foreach( LItem item in help.Context.Links ) Console.WriteLine("URL: {0}, LinkGroup: {1}, Title: {2}", item.URL.Substring(0, 15), item.LinkGroup, item.Title);
屏幕显示:
未处理的异常: System.InvalidOperationException: XML 文档(4, 2)中有错误。 ---> System.InvalidOperationException: 不应有 <DynamicHelp xmlns='http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd'>。
哦,抛异常了。 别急,看看异常说什么。 好像是在说命名空间不能识别。 根据异常的描述,我还要修改一下DynamicHelp的定义,改成这样:
[XmlRoot(Namespace = "http://msdn.microsoft.com/vsdata/xsd/vsdh.xsd")] public class DynamicHelp
再次运行,结果如下:
ID: sites, Title: Venus Sites, Priority: 1500, Collapsed: 3, Expanded: 4 ID: Venus Private Forums, Title: Venus Private Forums, Priority: 1400, Collapsed: 3, Expanded: 4 ID: ASP.NET Forums, Title: ASP.NET 1.0 Public Forums, Priority: 1200, Collapsed: 3, Expanded: 4 URL: http://www.asp., LinkGroup: sites, Title: Venus Home Page URL: http://www.asp., LinkGroup: sites, Title: ASP.NET Home Page URL: http://www.asp., LinkGroup: Venus Private Forums, Title: General Discussions URL: http://www.asp., LinkGroup: Venus Private Forums, Title: Feature Requests URL: http://www.asp., LinkGroup: Venus Private Forums, Title: Bug Reports URL: http://www.asp., LinkGroup: Venus Private Forums, Title: ASP.NET 2.0 Related issues URL: http://www.asp., LinkGroup: ASP.NET Forums, Title: Announcements URL: http://www.asp., LinkGroup: ASP.NET Forums, Title: Getting Started URL: 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]来指出,例如:public class TestIgnore { [XmlIgnore] // 这个属性将不会参与序列化 public int IntValue { get; set; } public string StrValue { get; set; } public string Url; }
序列化调用代码:
TestIgnore c1 = new TestIgnore { IntValue = 3, StrValue = "Fish Li" }; c1.Url = "http://www.cnblogs.com/fish-li/"; string xml = XmlHelper.XmlSerialize(c1, Encoding.UTF8); Console.WriteLine(xml);
输出结果如下:
<?xml version="1.0" encoding="utf-8"?> <TestIgnore xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Url>http://www.cnblogs.com/fish-li/</Url> <StrValue>Fish Li</StrValue> </TestIgnore>
回到顶部
强制指定成员的序列化顺序
前面的示例很奇怪,我明明先定义的StrValue,后定义的Url,可是在输出时的顺序并是我期望的。 如果你希望控制序列化的输出顺序,可以参考下面的示例代码(注意红色粗体文字):public class TestIgnore { [XmlIgnore] // 这个属性将不会参与序列化 public int IntValue { get; set; } [XmlElement(Order = 1)] public string StrValue { get; set; } [XmlElement(Order = 2)] public string Url; }
最终的输出结果如下:
<?xml version="1.0" encoding="utf-8"?> <TestIgnore xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <StrValue>Fish Li</StrValue> <Url>http://www.cnblogs.com/fish-li/</Url> </TestIgnore>
回到顶部
自定义序列化行为
由于种种原因,可能需要我们自己控制序列化和反序列化的过程, 对于这种需求, .net framework也是支持的,下面我来演示如何这个过程。假如我现在有这样的类型定义:
public class TestClass { public string StrValue { get; set; } public List<int> List { get; set; } } public class ClassB1 { public TestClass Test { get; set; } }
测试代码:
TestClass test = new TestClass { StrValue = "Fish Li", List = new List<int> { 1, 2, 3, 4, 5 } }; ClassB1 b1 = new ClassB1 { Test = test }; string xml = XmlHelper.XmlSerialize(b1, Encoding.UTF8); Console.WriteLine(xml); Console.WriteLine("-----------------------------------------------------"); ClassB1 b2 = XmlHelper.XmlDeserialize<ClassB1>(xml, Encoding.UTF8); Console.WriteLine("StrValue: " + b2.Test.StrValue); foreach( int n in b2.Test.List ) Console.WriteLine(n);
此时程序的输出结果如下:
<?xml version="1.0" encoding="utf-8"?> <ClassB1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Test> <StrValue>Fish Li</StrValue> <List> <int>1</int> <int>2</int> <int>3</int> <int>4</int> <int>5</int> </List> </Test> </ClassB1> ----------------------------------------------------- StrValue: Fish Li 1 2 3 4 5
现在我可能会想:TestClass这个类太简单了,但它输出的XML长度复杂了点,能不能再短小一点,让网络传输地更快呢?
在这里,我想到了自定义序列化行为来实现,请看下面对TestClass的重新定义。
public class TestClass : IXmlSerializable { public string StrValue { get; set; } public List<int> List { get; set; } public System.Xml.Schema.XmlSchema GetSchema() { return null; } public void ReadXml(XmlReader reader) { StrValue = reader.GetAttribute("s"); string numbers = reader.ReadString(); if( string.IsNullOrEmpty(numbers) == false ) List = (from s in numbers.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries) let n = int.Parse(s) select n).ToList(); } public void WriteXml(XmlWriter writer) { writer.WriteAttributeString("s", StrValue); writer.WriteString(string.Join(",", List.ConvertAll<string>(x => x.ToString()).ToArray())); } }
继续使用前面的测试代码,现在的输出结果如下:
<?xml version="1.0" encoding="utf-8"?> <ClassB1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Test s="Fish Li">1,2,3,4,5</Test> </ClassB1> ----------------------------------------------------- StrValue: Fish Li 1 2 3 4 5
很明显,现在的序列化结果要比以前的结果小很多。 而且,测试代码中的反序列化的显示也表明,我们仍然可以通过反序列化来读取它。
回到顶部
序列化去掉XML命名空间及声明头
在前面的示例中,我们会发现有时很简单的XML在加了命名空间及声明头以后,结构变复杂了,内容也变长了。 有些人看到它们可能总是感觉非常别扭,例如:<?xml version="1.0" encoding="utf-8"?> <ClassB1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Test s="Fish Li">1,2,3,4,5</Test> </ClassB1>
能不能只显示成下面这样呢?
<ClassB1> <Test s="Fish Li">1,2,3,4,5</Test> </ClassB1>
答案是肯定的,按下面的方法修改本文的示例代码:
private static void XmlSerializeInternal(Stream stream, object o, Encoding encoding) { if( o == null ) throw new ArgumentNullException("o"); if( encoding == null ) throw new ArgumentNullException("encoding"); XmlSerializer serializer = new XmlSerializer(o.GetType()); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.NewLineChars = "\r\n"; settings.Encoding = encoding; settings.IndentChars = " "; // 不生成声明头 settings.OmitXmlDeclaration = true; // 强制指定命名空间,覆盖默认的命名空间。 XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(); namespaces.Add(string.Empty, string.Empty); using( XmlWriter writer = XmlWriter.Create(stream, settings) ) { serializer.Serialize(writer, o, namespaces); writer.Close(); } }
说明:去掉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 。
XSD与C#Code以及XML之间的相互关心
http://www.cnblogs.com/shiyun/p/3177193.html------------------------------网上参考资料
C# 利用自带xsd.exe工具操作XML-如通过XML生成xsd文件:http://blog.sina.com.cn/s/blog_7a8de3410100xlyl.html
xsd文件转换为实体类:http://code.3rbang.com/xsdtoclass/
如何动态根据一个业务实体类型创建XSD架构文件:http://developer.51cto.com/art/200908/143058.htm
using System;
using System.Collections.Generic;
using System.Text;
namespace DataEntities
{
public class Order
{
public int OrderID { get; set; }
public string CustomerID { get; set; }
public int EmployeeID { get; set; }
public DateTime OrderDate { get; set; }
public List<OrderItem> OrderItems { get; set; }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("\t{0}\t{1}\t{2}\t{3}", OrderID, CustomerID, EmployeeID, OrderDate);
sb.AppendLine();
foreach (var item in OrderItems)
{
sb.AppendFormat("\t\t{0}\t{1}\t{2}\n", item.Product.ProductName, item.UnitPrice, item.Quantity);
}
return sb.ToString();
}
}
public class OrderItem
{
public int OrderId { get; set; }
public Product Product { get; set; }
public decimal UnitPrice { get; set; }
public decimal Quantity { get; set; }
}
public class Product
{
public int ProductId { get; set; }
public string ProductName { get; set; }
}
}
创建XSD架构文件第二部分:生成XSD的工具类(Utility.cs)
using System;
using System.Xml.Linq;
using System.Collections;
using System.Xml;
namespace XMLDatabase
{
public class Utility
{
/// <summary>
/// 使用指定类型生成一个架构文件
/// </summary>
/// <typeparamname="T"></typeparam>
public static void XsdGenerate<T>(XmlWriter xw) {
Type t = typeof(T);
XNamespace xn = "http://www.w3.org/2001/XMLSchema";
XDocument doc = new XDocument(
new XDeclaration("1.0", "utf-8", "yes"),
new XElement(xn + "schema",
new XAttribute("elementFormDefault", "qualified"),
new XAttribute(XNamespace.Xmlns + "xs", "http://www.w3.org/2001/XMLSchema"),
new XElement(xn+"element",
new XAttribute("name","Table"),
new XAttribute("nillable","true"),
new XAttribute("type","Table"))
));
XElement tableElement = new XElement(xn + "complexType",
new XAttribute("name", "Table"));
tableElement.Add(
new XElement(xn + "sequence",
new XElement(xn + "element",
new XAttribute("minOccurs", "0"),
new XAttribute("maxOccurs", "unbounded"),
new XAttribute("name","Row"),
new XAttribute("type",t.Name)
)),
new XElement(xn + "attribute",
new XAttribute("name", "CreateTime"),
new XAttribute("type", "xs:string"))
);
doc.Root.Add(tableElement);
CreateComplexType(t, doc.Root);
doc.Save(xw);
}
private static void CreateComplexType(Type t,XElement root) {
XNamespace xn = root.GetNamespaceOfPrefix("xs");
XElement temp = new XElement(
xn + "complexType",
new XAttribute("name", t.Name));
#region 循环所有属性
foreach (var p in t.GetProperties())//循环所有属性
{
Type ppType = p.PropertyType;
string fullType = pType.FullName;
//这里仍然是分几种情况
if (!GeneralType.Contains(fullType))
{
var seqelement = temp.Element(xn + "sequence");
if (seqelement == null)
{
seqelement = new XElement(xn + "sequence");
temp.AddFirst(seqelement);
}
if (pType.IsEnum)//如果是枚举
{
seqelement.Add(
new XElement(
xn + "element",
new XAttribute("minOccurs", "0"),
new XAttribute("maxOccurs", "1"),
new XAttribute("name", p.Name),
new XAttribute("type", pType.Name)));
XElement enumElement = new XElement(
xn + "complexType",
new XAttribute("name", pType.Name),
new XElement(xn + "attribute",
new XAttribute("name", "Enum"),
new XAttribute("type", "xs:string")));
root.Add(enumElement);
}
else if (pType.GetInterface(typeof(IList).FullName) != null && pType.IsGenericType)
//如果是集合,并且是泛型集合
{
Type itemType = pType.GetGenericArguments()[0];
seqelement.Add(
new XElement(
xn + "element",
new XAttribute("minOccurs", "0"),
new XAttribute("maxOccurs", "1"),
new XAttribute("name", p.Name),
new XAttribute("type", "ArrayOf"+p.Name)));
XElement arrayElement = new XElement(
xn + "complexType",
new XAttribute("name", "ArrayOf" + p.Name),
new XElement(xn + "sequence",
new XElement(xn + "element",
new XAttribute("minOccurs", "0"),
new XAttribute("maxOccurs", "unbounded"),
new XAttribute("name", itemType.Name),
new XAttribute("type", itemType.Name))));
root.Add(arrayElement);
CreateComplexType(itemType, root);
}
else if (pType.IsClass || pType.IsValueType)
{
seqelement.Add(
new XElement(
xn + "element",
new XAttribute("minOccurs", "0"),
new XAttribute("maxOccurs", "1"),
new XAttribute("name", p.Name),
new XAttribute("type", pType.Name)));
CreateComplexType(pType, root);
}
}
else
{
//这种情况最简单,属性为标准内置类型,直接作为元素的Attribute即可
temp.Add(
new XElement(xn + "attribute",
new XAttribute("name", p.Name),
new XAttribute("type", GeneralType.ConvertXSDType(pType.FullName))));
}
}
#endregion
temp.Add(new XElement(xn + "attribute",
new XAttribute("name", "TypeName"),
new XAttribute("type", "xs:string")));
root.Add(temp);
}
}
}
创建XSD架构文件第三部分:辅助类型(GeneralType.cs).
这个类型中有一个方法可以将业务实体类型成员属性的类型转换为XSD中 的类型。
using System;
using System.Collections.Generic;
using System.Text;
namespace XMLDatabase
{
public class GeneralType
{
private static readonly List<string>generalTypes = new List<string>()
{
"System.Byte",//typeof(byte).FullName,
"System.SByte",//typeof(sbyte).FullName,
"System.Int16",//typeof(short).FullName,
"System.UInt16",//typeof(ushort).FullName,
"System.Int32",//typeof(int).FullName,
"System.UInt32",//typeof(uint).FullName,
"System.Int64",//typeof(long).FullName,
"System.UInt64",//typeof(ulong).FullName,
"System.Double",//typeof(double).FullName,
"System.Decimal",//typeof(decimal).FullName,
"System.Single",//typeof(float).FullName,
"System.Char",//typeof(char).FullName,
"System.Boolean",//typeof(bool).FullName,
"System.String",//typeof(string).FullName,
"System.DateTime"//typeof(DateTime).FullName
};
/// <summary>
/// 判断当前给定类型是否为默认的数据类型
/// </summary>
/// <paramname="fullType"></param>
/// <returns></returns>
public static bool Contains(string fullType)
{
return generalTypes.Contains(fullType);
}
public static string ConvertXSDType(string fullType)
{
switch (fullType)
{
case "System.String":
return "xs:string";
case "System.Int32":
return "xs:int";
case "System.DateTime":
return "xs:dateTime";
case "System.Boolean":
return "xs:boolean";
case "System.Single":
return "xs:float";
case "System.Byte":
return "xs:byte";
case "System.SByte":
return "xs:unsignedByte";
case "System.Int16":
return "xs:short";
case "System.UInt16":
return "xs:unsignedShort";
case "System.UInt32":
return "xs:unsignedInt";
case "System.Int64":
return "xs:long";
case "System.UInt64":
return "xs:unsignedLong";
case "System.Double":
return "xs:double";
case "System.Decimal":
return "xs:decimal";
default:
break;
}
return string.Empty;
}
}
}
创建XSD架构文件第四部分:单元测试
/// <summary>
///XsdGenerate 的测试
///</summary>
public void XsdGenerateTestHelper<T>()
{
XmlWriter xw = XmlWriter.Create("Order.xsd"); // TODO: 初始化为适当的值
Utility.XsdGenerate<Order>(xw);
xw.Close();
}
创建XSD架构文件第五部分: 生成的结果
<?xmlversion="1.0"encoding="utf-8"standalone="yes"?>
<xs:schemaelementFormDefault="qualified"xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:elementname="Table"nillable="true"type="Table"/>
<xs:complexTypename="Table">
<xs:sequence>
<xs:elementminOccurs="0"maxOccurs="unbounded"name="Row"type="Order"/>
</xs:sequence>
<xs:attributename="CreateTime"type="xs:string"/>
</xs:complexType>
<xs:complexTypename="ArrayOfOrderItems">
<xs:sequence>
<xs:elementminOccurs="0"maxOccurs="unbounded"name="OrderItem"type="OrderItem"/>
</xs:sequence>
</xs:complexType>
<xs:complexTypename="Product">
<xs:attributename="ProductId"type="xs:int"/>
<xs:attributename="ProductName"type="xs:string"/>
<xs:attributename="TypeName"type="xs:string"/>
</xs:complexType>
<xs:complexTypename="OrderItem">
<xs:sequence>
<xs:elementminOccurs="0"maxOccurs="1"name="Product"type="Product"/>
</xs:sequence>
<xs:attributename="OrderId"type="xs:int"/>
<xs:attributename="UnitPrice"type="xs:decimal"/>
<xs:attributename="Quantity"type="xs:decimal"/>
<xs:attributename="TypeName"type="xs:string"/>
</xs:complexType>
<xs:complexTypename="Order">
<xs:sequence>
<xs:elementminOccurs="0"maxOccurs="1"name="OrderItems"type="ArrayOfOrderItems"/>
</xs:sequence>
<xs:attributename="OrderID"type="xs:int"/>
<xs:attributename="CustomerID"type="xs:string"/>
<xs:attributename="EmployeeID"type="xs:int"/>
<xs:attributename="OrderDate"type="xs:dateTime"/>
<xs:attributename="TypeName"type="xs:string"/>
</xs:complexType>
</xs:schema>
创建XSD架构文件第六部分:合法的数据文件范例
<?xmlversion="1.0"encoding="utf-8"?>
<TableName="Orders"CreateTime="2009/8/9 21:59:04">
<RowTypeName="DataEntities.Order"OrderID="10249"CustomerID="ABCDEF"EmployeeID="1"OrderDate="2009-08-09T21:59:04.125+08:00">
<OrderItems>
<OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="25"Quantity="4">
<ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Pen"/>
</OrderItem>
<OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="2"Quantity="2000">
<ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Car"/>
</OrderItem>
</OrderItems>
</Row>
<RowTypeName="DataEntities.Order"OrderID="10249"CustomerID="ABCDEF"EmployeeID="1"OrderDate="2009-08-10T07:29:51.546875+08:00">
<OrderItems>
<OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="25"Quantity="4">
<ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Pen"/>
</OrderItem>
<OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="2"Quantity="2000">
<ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Car"/>
</OrderItem>
</OrderItems>
</Row>
<RowTypeName="DataEntities.Order"OrderID="10249"CustomerID="ABCDEF"EmployeeID="1"OrderDate="2009-08-10T07:30:13.375+08:00">
<OrderItems>
<OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="25"Quantity="4">
<ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Pen"/>
</OrderItem>
<OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="2"Quantity="2000">
<ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Car"/>
</OrderItem>
</OrderItems>
</Row>
<RowTypeName="DataEntities.Order"OrderID="10249"CustomerID="ABCDEF"EmployeeID="1"OrderDate="2009-08-10T07:30:43.875+08:00">
<OrderItems>
<OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="25"Quantity="4">
<ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Pen"/>
</OrderItem>
<OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="2"Quantity="2000">
<ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Car"/>
</OrderItem>
</OrderItems>
</Row>
</Table>
相关文章推荐
- 在.net中序列化读写xml方法的总结
- 在.net中序列化读写xml方法的总结
- 在.net中序列化读写xml方法的总结
- 在.net中序列化读写xml方法的总结
- 在.net中序列化读写xml方法的总结
- 在.net中序列化读写xml方法的总结--转载过来学习学习
- 在.net中序列化读写xml方法的总结
- 在.net中序列化读写xml方法的总结
- 在.net中序列化读写xml方法的总结
- C# 在.net中序列化读写xml方法的总结
- 在.net中序列化读写xml方法的总结
- 在.net中读写XML方法的总结
- 在.net中序列化读写xml方法
- 在.net中读写XML方法的总结
- 在.net中读写XML方法的总结[转]
- C#.NET示例读写xml所有节点的代码实现方法和读取xml节点的数据总结
- ASP.NET MVC WebApi 返回数据类型序列化控制(json,xml) 用javascript在客户端删除某一个cookie键值对 input点击链接另一个页面,各种操作。 C# 往线程里传参数的方法总结 TCP/IP 协议 用C#+Selenium+ChromeDriver 生成我的咕咚跑步路线地图 (转)值得学习百度开源70+项目
- C#.NET示例读写xml所有节点的代码实现方法和读取xml节点的数据总结
- C#.NET示例读写xml所有节点的代码实现方法和读取xml节点的数据总结
- C# XML序列化方法及常用特性总结分析