• 在.net中序列化读写xml方法的总结

    在.net中序列化读写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文件的各种方法】的示例代码
// http://www.cnblogs.com/fish-li/archive/2011/12/18/2292037.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 = "
";
            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&amp;ForumID=77" 
                    LinkGroup="Venus Private Forums">General Discussions</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=83" 
                    LinkGroup="Venus Private Forums">Feature Requests</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=78" 
                    LinkGroup="Venus Private Forums">Bug Reports</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=86" 
                    LinkGroup="Venus Private Forums">ASP.NET 2.0 Related issues</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=11" 
                    LinkGroup="ASP.NET Forums">Announcements</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=15" 
                    LinkGroup="ASP.NET Forums">Getting Started</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;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&amp;ForumID=77" 
                    LinkGroup="Venus Private Forums">General Discussions</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=83" 
                    LinkGroup="Venus Private Forums">Feature Requests</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=78" 
                    LinkGroup="Venus Private Forums">Bug Reports</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=86" 
                    LinkGroup="Venus Private Forums">ASP.NET 2.0 Related issues</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=11" 
                    LinkGroup="ASP.NET Forums">Announcements</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;ForumID=15" 
                    LinkGroup="ASP.NET Forums">Getting Started</LItem>
            <LItem URL="http://www.asp.net/Forums/ShowForum.aspx?tabindex=1&amp;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 = "
";
    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

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Text;
    4. namespace DataEntities
    5. {
    6. public class Order
    7. {
    8. public int OrderID { get; set; }
    9. public string CustomerID { get; set; }
    10. public int EmployeeID { get; set; }
    11. public DateTime OrderDate { get; set; }
    12. public List<OrderItem> OrderItems { get; set; }
    13. public override string ToString()
    14. {
    15. StringBuilder sb = new StringBuilder();
    16. sb.AppendFormat(" {0} {1} {2} {3}", OrderID, CustomerID, EmployeeID, OrderDate);
    17. sb.AppendLine();
    18. foreach (var item in OrderItems)
    19. {
    20. sb.AppendFormat(" {0} {1} {2} ", item.Product.ProductName, item.UnitPrice, item.Quantity);
    21. }
    22. return sb.ToString();
    23. }
    24. }
    25. public class OrderItem
    26. {
    27. public int OrderId { get; set; }
    28. public Product Product { get; set; }
    29. public decimal UnitPrice { get; set; }
    30. public decimal Quantity { get; set; }
    31. }
    32. public class Product
    33. {
    34. public int ProductId { get; set; }
    35. public string ProductName { get; set; }
    36. }
    37. }

    创建XSD架构文件第二部分：生成XSD的工具类(Utility.cs)

    1. using System;
    2. using System.Xml.Linq;
    3. using System.Collections;
    4. using System.Xml;
    5. namespace XMLDatabase
    6. {
    7. public class Utility
    8. {
    9. /// <summary>
    10. /// 使用指定类型生成一个架构文件
    11. /// </summary>
    12. /// <typeparamname="T"></typeparam>
    13. public static void XsdGenerate<T>(XmlWriter xw) {
    14. Type t = typeof(T);
    15. XNamespace xn = "http://www.w3.org/2001/XMLSchema";
    16. XDocument doc = new XDocument(
    17. new XDeclaration("1.0", "utf-8", "yes"),
    18. new XElement(xn + "schema",
    19. new XAttribute("elementFormDefault", "qualified"),
    20. new XAttribute(XNamespace.Xmlns + "xs", "http://www.w3.org/2001/XMLSchema"),
    21. new XElement(xn+"element",
    22. new XAttribute("name","Table"),
    23. new XAttribute("nillable","true"),
    24. new XAttribute("type","Table"))
    25. ));
    26. XElement tableElement = new XElement(xn + "complexType",
    27. new XAttribute("name", "Table"));
    28. tableElement.Add(
    29. new XElement(xn + "sequence",
    30. new XElement(xn + "element",
    31. new XAttribute("minOccurs", "0"),
    32. new XAttribute("maxOccurs", "unbounded"),
    33. new XAttribute("name","Row"),
    34. new XAttribute("type",t.Name)
    35. )),
    36. new XElement(xn + "attribute",
    37. new XAttribute("name", "CreateTime"),
    38. new XAttribute("type", "xs:string"))
    39. );
    40. doc.Root.Add(tableElement);
    41. CreateComplexType(t, doc.Root);
    42. doc.Save(xw);
    43. }
    44. private static void CreateComplexType(Type t,XElement root) {
    45. XNamespace xn = root.GetNamespaceOfPrefix("xs");
    46. XElement temp = new XElement(
    47. xn + "complexType",
    48. new XAttribute("name", t.Name));
    49. #region 循环所有属性
    50. foreach (var p in t.GetProperties())//循环所有属性
    51. {
    52. Type ppType = p.PropertyType;
    53. string fullType = pType.FullName;
    54. //这里仍然是分几种情况
    55. if (!GeneralType.Contains(fullType))
    56. {
    57. var seqelement = temp.Element(xn + "sequence");
    58. if (seqelement == null)
    59. {
    60. seqelement = new XElement(xn + "sequence");
    61. temp.AddFirst(seqelement);
    62. }
    63. if (pType.IsEnum)//如果是枚举
    64. {
    65. seqelement.Add(
    66. new XElement(
    67. xn + "element",
    68. new XAttribute("minOccurs", "0"),
    69. new XAttribute("maxOccurs", "1"),
    70. new XAttribute("name", p.Name),
    71. new XAttribute("type", pType.Name)));
    72. XElement enumElement = new XElement(
    73. xn + "complexType",
    74. new XAttribute("name", pType.Name),
    75. new XElement(xn + "attribute",
    76. new XAttribute("name", "Enum"),
    77. new XAttribute("type", "xs:string")));
    78. root.Add(enumElement);
    79. }
    80. else if (pType.GetInterface(typeof(IList).FullName) != null && pType.IsGenericType)
    81. //如果是集合,并且是泛型集合
    82. {
    83. Type itemType = pType.GetGenericArguments()[0];
    84. seqelement.Add(
    85. new XElement(
    86. xn + "element",
    87. new XAttribute("minOccurs", "0"),
    88. new XAttribute("maxOccurs", "1"),
    89. new XAttribute("name", p.Name),
    90. new XAttribute("type", "ArrayOf"+p.Name)));
    91. XElement arrayElement = new XElement(
    92. xn + "complexType",
    93. new XAttribute("name", "ArrayOf" + p.Name),
    94. new XElement(xn + "sequence",
    95. new XElement(xn + "element",
    96. new XAttribute("minOccurs", "0"),
    97. new XAttribute("maxOccurs", "unbounded"),
    98. new XAttribute("name", itemType.Name),
    99. new XAttribute("type", itemType.Name))));
    100. root.Add(arrayElement);
    101. CreateComplexType(itemType, root);
    102. }
    103. else if (pType.IsClass || pType.IsValueType)
    104. {
    105. seqelement.Add(
    106. new XElement(
    107. xn + "element",
    108. new XAttribute("minOccurs", "0"),
    109. new XAttribute("maxOccurs", "1"),
    110. new XAttribute("name", p.Name),
    111. new XAttribute("type", pType.Name)));
    112. CreateComplexType(pType, root);
    113. }
    114. }
    115. else
    116. {
    117. //这种情况最简单，属性为标准内置类型，直接作为元素的Attribute即可
    118. temp.Add(
    119. new XElement(xn + "attribute",
    120. new XAttribute("name", p.Name),
    121. new XAttribute("type", GeneralType.ConvertXSDType(pType.FullName))));
    122. }
    123. }
    124. #endregion
    125. temp.Add(new XElement(xn + "attribute",
    126. new XAttribute("name", "TypeName"),
    127. new XAttribute("type", "xs:string")));
    128. root.Add(temp);
    129. }
    130. }
    131. }

    创建XSD架构文件第三部分：辅助类型(GeneralType.cs).

    这个类型中有一个方法可以将业务实体类型成员属性的类型转换为XSD中 的类型。

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Text;
    4. namespace XMLDatabase
    5. {
    6. public class GeneralType
    7. {
    8. private static readonly List<string>generalTypes = new List<string>()
    9. {
    10. "System.Byte",//typeof(byte).FullName,
    11. "System.SByte",//typeof(sbyte).FullName,
    12. "System.Int16",//typeof(short).FullName,
    13. "System.UInt16",//typeof(ushort).FullName,
    14. "System.Int32",//typeof(int).FullName,
    15. "System.UInt32",//typeof(uint).FullName,
    16. "System.Int64",//typeof(long).FullName,
    17. "System.UInt64",//typeof(ulong).FullName,
    18. "System.Double",//typeof(double).FullName,
    19. "System.Decimal",//typeof(decimal).FullName,
    20. "System.Single",//typeof(float).FullName,
    21. "System.Char",//typeof(char).FullName,
    22. "System.Boolean",//typeof(bool).FullName,
    23. "System.String",//typeof(string).FullName,
    24. "System.DateTime"//typeof(DateTime).FullName
    25. };
    26. /// <summary>
    27. /// 判断当前给定类型是否为默认的数据类型
    28. /// </summary>
    29. /// <paramname="fullType"></param>
    30. /// <returns></returns>
    31. public static bool Contains(string fullType)
    32. {
    33. return generalTypes.Contains(fullType);
    34. }
    35. public static string ConvertXSDType(string fullType)
    36. {
    37. switch (fullType)
    38. {
    39. case "System.String":
    40. return "xs:string";
    41. case "System.Int32":
    42. return "xs:int";
    43. case "System.DateTime":
    44. return "xs:dateTime";
    45. case "System.Boolean":
    46. return "xs:boolean";
    47. case "System.Single":
    48. return "xs:float";
    49. case "System.Byte":
    50. return "xs:byte";
    51. case "System.SByte":
    52. return "xs:unsignedByte";
    53. case "System.Int16":
    54. return "xs:short";
    55. case "System.UInt16":
    56. return "xs:unsignedShort";
    57. case "System.UInt32":
    58. return "xs:unsignedInt";
    59. case "System.Int64":
    60. return "xs:long";
    61. case "System.UInt64":
    62. return "xs:unsignedLong";
    63. case "System.Double":
    64. return "xs:double";
    65. case "System.Decimal":
    66. return "xs:decimal";
    67. default:
    68. break;
    69. }
    70. return string.Empty;
    71. }
    72. }
    73. }

    创建XSD架构文件第四部分：单元测试

    1. /// <summary>
    2. ///XsdGenerate 的测试
    3. ///</summary>
    4. public void XsdGenerateTestHelper<T>()
    5. {
    6. XmlWriter xw = XmlWriter.Create("Order.xsd"); // TODO: 初始化为适当的值
    7. Utility.XsdGenerate<Order>(xw);
    8. xw.Close();
    9. }

    创建XSD架构文件第五部分： 生成的结果

    1. <?xmlversion="1.0"encoding="utf-8"standalone="yes"?>
    2. <xs:schemaelementFormDefault="qualified"xmlns:xs="http://www.w3.org/2001/XMLSchema">
    3. <xs:elementname="Table"nillable="true"type="Table"/>
    4. <xs:complexTypename="Table">
    5. <xs:sequence>
    6. <xs:elementminOccurs="0"maxOccurs="unbounded"name="Row"type="Order"/>
    7. </xs:sequence>
    8. <xs:attributename="CreateTime"type="xs:string"/>
    9. </xs:complexType>
    10. <xs:complexTypename="ArrayOfOrderItems">
    11. <xs:sequence>
    12. <xs:elementminOccurs="0"maxOccurs="unbounded"name="OrderItem"type="OrderItem"/>
    13. </xs:sequence>
    14. </xs:complexType>
    15. <xs:complexTypename="Product">
    16. <xs:attributename="ProductId"type="xs:int"/>
    17. <xs:attributename="ProductName"type="xs:string"/>
    18. <xs:attributename="TypeName"type="xs:string"/>
    19. </xs:complexType>
    20. <xs:complexTypename="OrderItem">
    21. <xs:sequence>
    22. <xs:elementminOccurs="0"maxOccurs="1"name="Product"type="Product"/>
    23. </xs:sequence>
    24. <xs:attributename="OrderId"type="xs:int"/>
    25. <xs:attributename="UnitPrice"type="xs:decimal"/>
    26. <xs:attributename="Quantity"type="xs:decimal"/>
    27. <xs:attributename="TypeName"type="xs:string"/>
    28. </xs:complexType>
    29. <xs:complexTypename="Order">
    30. <xs:sequence>
    31. <xs:elementminOccurs="0"maxOccurs="1"name="OrderItems"type="ArrayOfOrderItems"/>
    32. </xs:sequence>
    33. <xs:attributename="OrderID"type="xs:int"/>
    34. <xs:attributename="CustomerID"type="xs:string"/>
    35. <xs:attributename="EmployeeID"type="xs:int"/>
    36. <xs:attributename="OrderDate"type="xs:dateTime"/>
    37. <xs:attributename="TypeName"type="xs:string"/>
    38. </xs:complexType>
    39. </xs:schema>

    创建XSD架构文件第六部分：合法的数据文件范例

    1. <?xmlversion="1.0"encoding="utf-8"?>
    2. <TableName="Orders"CreateTime="2009/8/9 21:59:04">
    3. <RowTypeName="DataEntities.Order"OrderID="10249"CustomerID="ABCDEF"EmployeeID="1"OrderDate="2009-08-09T21:59:04.125+08:00">
    4. <OrderItems>
    5. <OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="25"Quantity="4">
    6. <ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Pen"/>
    7. </OrderItem>
    8. <OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="2"Quantity="2000">
    9. <ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Car"/>
    10. </OrderItem>
    11. </OrderItems>
    12. </Row>
    13. <RowTypeName="DataEntities.Order"OrderID="10249"CustomerID="ABCDEF"EmployeeID="1"OrderDate="2009-08-10T07:29:51.546875+08:00">
    14. <OrderItems>
    15. <OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="25"Quantity="4">
    16. <ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Pen"/>
    17. </OrderItem>
    18. <OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="2"Quantity="2000">
    19. <ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Car"/>
    20. </OrderItem>
    21. </OrderItems>
    22. </Row>
    23. <RowTypeName="DataEntities.Order"OrderID="10249"CustomerID="ABCDEF"EmployeeID="1"OrderDate="2009-08-10T07:30:13.375+08:00">
    24. <OrderItems>
    25. <OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="25"Quantity="4">
    26. <ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Pen"/>
    27. </OrderItem>
    28. <OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="2"Quantity="2000">
    29. <ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Car"/>
    30. </OrderItem>
    31. </OrderItems>
    32. </Row>
    33. <RowTypeName="DataEntities.Order"OrderID="10249"CustomerID="ABCDEF"EmployeeID="1"OrderDate="2009-08-10T07:30:43.875+08:00">
    34. <OrderItems>
    35. <OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="25"Quantity="4">
    36. <ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Pen"/>
    37. </OrderItem>
    38. <OrderItemTypeName="DataEntities.OrderItem"OrderId="10249"UnitPrice="2"Quantity="2000">
    39. <ProductTypeName="DataEntities.Product"ProductId="1"ProductName="Car"/>
    40. </OrderItem>
    41. </OrderItems>
    42. </Row>
    43. </Table>
  • 相关阅读:
    20220530复盘
    20220524复盘
    20220523复盘
    20220520复盘
    22020527复盘
    sys模块
    mongodb安装部署
    weblogic12c安装部署
    python字符串操作
    pythonpyttsx3模块
  • 原文地址：https://www.cnblogs.com/qq260250932/p/4245374.html
Copyright © 2020-2023  润新知