利用Xml架构生成实体访问类

由xml生成xsd及实体类

 

xmldataset工具

使用VS2005工具XSD.exe(SDK/v2.0/Bin/xsd.exe)自动生成实体类：

xsd /c /namespace:myCompany /language:CS temp1.xsd

也可以生成DataSet类型的类:

xsd /dataset /language:CS temp1.xsd

( 类文件和XSD之间可以相互转换，也就是说，你也可以先生成类，然后自动生成XSD)

自动读取XML数据到实体类：

XmlSerializer xs = new XmlSerializer(typeof(myClassType)); using (FileStream fs = new FileStream(XmlFilePath, FileMode.Open)) {     return (myClassType)xs.Deserialize(fs); }

use XSD.exe in VS2010 from a xsd file to class

1.use XSD.exe

Start -> All Programs -> Microsoft Visual Studio 2010 -> Visual Studio Tools -> Visual Studio Command Prompt

2.from a xsd file to class

xsd /c /namespace:myCompany /language:CS temp1.xsd

系统：Windows 2003 Server SP2

工具：VS2008

第一步：创建Xml文件架构

首先在VS2008中打开编写好的Xml文件(或在VS2008中直接编辑)-->点击工具栏的“Xml”(如果打开的不是Xml文件，此菜单不显示)

-->点击“创建架构”(会生产一个*.xsd的文件)-->把此文件进行保存(记住保存的目录，之后要用到)-->完毕。

第二步：通过架构生成实体访问类

首先从“开始”-->“所有程序”-->“Microsoft Visual Studio 2008”-->“Visual Studio Tools”中打开“Visual Studio 2008命令提示”，然后在里面输入“xsd.exe /c /l:c# 刚才文件保存的路径”，执行以下就OK了，生成的实体访问类在执行界面有显示，一般为：“C:/Program Files/Microsoft Visual Studio 9.0/VC/*.cs”。

第三步：定义读取访问类

把生产的Xml拷贝到使用程序中，并增加如下访问类：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Xml.Serialization;
6. namespace 命名空间
7. {
8. public class XmlInstanceClass
9. {
10. public static configuration GetInterFaceConfig()
11. {
12. configuration ResultCon = null;
13. string XmlPath = 程序中的Xml路径;
14. System.IO.FileStream FS = null;
15. System.Xml.Serialization.XmlSerializer XmlSerializer = new XmlSerializer(typeof(configuration));
16. try
17. {
18. FS = new System.IO.FileStream(XmlPath, System.IO.FileMode.Open, System.IO.FileAccess.Read);
19. ResultCon = (configuration)XmlSerializer.Deserialize(FS);
20. }
21. catch (Exception ex)
22. {
23. throw new Exception(ex.Message);
24. }
25. finally
26. {
27. FS.Close();
28. }
29. return ResultCon;
30. }
31. }
32. }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;

namespace 命名空间
{
public class XmlInstanceClass
{
public static configuration GetInterFaceConfig()
{
configuration ResultCon = null;
string XmlPath = 程序中的Xml路径;
System.IO.FileStream FS = null;

System.Xml.Serialization.XmlSerializer XmlSerializer = new XmlSerializer(typeof(configuration));
try
{
FS = new System.IO.FileStream(XmlPath, System.IO.FileMode.Open, System.IO.FileAccess.Read);
ResultCon = (configuration)XmlSerializer.Deserialize(FS);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
FS.Close();
}
return ResultCon;
}
}
}

第四步：在其他类中使用

configuration ResultCon=XmlInstanceClass.GetInterFaceConfig();

这样值就读入了ResultCon，之后就可以根据业务自定义使用了。

备注：如果对“xsd.exe ”命令不太熟悉，可以直接输入xsd.exe点击“Enter”查看帮助说明；

‘/c’：代表输出的为类文件；

‘/l:c#’：代表输出的类文件所使用的编程语言。

XML文件与实体类的互相转换

一.将XML文件反序列化为实体类对象

　　1. 通常程序的配置信息都保存在程序或者网站的专门的配置文件中(App.config/web.config)。但是现在为了演示XML序列化和反序列化，将配置信息保存在一个XML文件(config.xml)中，通过反序列化将配置信息读取出来保存到一个单独的类(Config.cs)中。这样如果需要用到配置信息，没必要每次都读写XML文件，只需要调用Config这个类就可以获取对应节点的信息。

　　config.xml:

<?xml version="1.0" encoding="utf-8"?>
<Config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" IsAuto="true">

  <Description>定时扫描数据库，通过客户号和业务号读取客户信息</Description>

  <CustomerInfos>
    <CustomerInfo>
      <CustomerId>0013</CustomerId>
      <BusinessId>03</BusinessId>
    </CustomerInfo>
    <CustomerInfo>
      <CustomerId>0022</CustomerId>
      <BusinessId>02</BusinessId>
    </CustomerInfo>
  </CustomerInfos>

  <ScanConfigs>
    <BeginTime>22:00:00</BeginTime>
    <EndTimme>23:00:00</EndTimme>
  </ScanConfigs>

</Config>

　　2. 为了将上面这个XML转换为想要的实体类对象，方便在程序里面读取节点数据，需要创建一个相对应的实体类，在实体类中用[XmlRoot][XmlElement][XmlAttribute]等属性标识。

　　Config.cs:

　　//XmlRoot表明这个类对应的是XML文件中的根节点
　　[XmlRoot(ElementName="Config")]
    public class Config
    {
　　　　　//XmlElement表明这个字段对应的是XML文件中当前父节点下面的一个子节点
　　　　　//ElementName就是XML里面显示的当前节点名称
　　　　　//类中的字段名称与对应的XML节点的名称可以不同(比如在这里类Config中的属性ClientDescription对应XML文件中根节点Config下面的子节点Description)
        [XmlElement(ElementName = "Description")]
        public string ClientDescription { get; set; }

　　　　　//XmlAttribute表明这个字段是XML文件中当前节点的一个属性
        [XmlAttribute(AttributeName="IsAuto")]
        public string IsAuto { get; set; }

        [XmlElement(ElementName = "CustomerInfos")]
        public CustomerInfos CustomerInfos
        {
            get;
            set;
        }

        [XmlElement(ElementName = "ScanConfigs")]
        public ScanConfigs ScanConfigs
        {
            get;
            set;
        }
    }

    public class CustomerInfos
    {
        [XmlElement(ElementName = "CustomerInfo")]
        public CustomerInfo[] cs
        {
            get;
            set;
        }
    }

    public class CustomerInfo
    {
        [XmlElement(ElementName = "CustomerId")]
        public string CustomerId { get; set; }

        [XmlElement(ElementName = "BusinessId")]
        public string BusinessId { get; set; }
    }

    public class ScanConfigs
    {
        [XmlElement(ElementName = "BeginTime")]
        public string BeginTime { get; set; }

        [XmlElement(ElementName = "EndTimme")]
        public string EndTimme { get; set; }
    }

　　3. 下面的代码调用.net的XmlSerializer类的方法进行XML的反序列化

　　public class XmlUtil
    {
        //反序列化
　　　　 //接收2个参数:xmlFilePath(需要反序列化的XML文件的绝对路径),type(反序列化XML为哪种对象类型)
        public static object DeserializeFromXml(string xmlFilePath, Type type)
        {
            object result = null;
            if (File.Exists(xmlFilePath))
            {
                using (StreamReader reader = new StreamReader(xmlFilePath))
                {
                    XmlSerializer xs = new XmlSerializer(type);
                    result = xs.Deserialize(reader);
                }
            }
            return result;
        }
    }

　　4. 反序列化

　　 string xmlPath = "d:\\config.xml";
    Config c = XmlUtil.DeserializeFromXml(xmlPath, typeof(Config)) as Config;

二. 序列化

　　1. 反过来的，也可以将Config类的一个对象序列化为XML文件.下面的代码通过调用.net的XmlSerializer类的方法将对象序列化为XML文件

　　public class XmlUtil
    {
        //序列化
　　　　 //接收4个参数:srcObject(对象的实例),type(对象类型),xmlFilePath(序列化之后的xml文件的绝对路径),xmlRootName(xml文件中根节点名称)
　　　　 //当需要将多个对象实例序列化到同一个XML文件中的时候,xmlRootName就是所有对象共同的根节点名称,如果不指定,.net会默认给一个名称(ArrayOf+实体类名称)
        public static void SerializeToXml(object srcObject, Type type,string xmlFilePath, string xmlRootName)
        {
            if (srcObject != null && !string.IsNullOrEmpty(xmlFilePath))
            {
                type = type != null ? type : srcObject.GetType();

                using(StreamWriter sw=new StreamWriter(xmlFilePath))
                {
                    XmlSerializer xs = string.IsNullOrEmpty(xmlRootName) ?
                        new XmlSerializer(type) :
                        new XmlSerializer(type, new XmlRootAttribute(xmlRootName));
                    xs.Serialize(sw, srcObject);
                }
            }
        }
    }

　　2. 序列化

　　　　　　　Config config = new Config();
            config.ClientDescribe = "定时扫描数据库，通过客户号和业务号读取客户信息.";
            config.IsAuto = "true";

            CustomerInfo ci1 = new CustomerInfo();
            ci1.CustomerId = "0013";
            ci1.BusinessId = "03";
            CustomerInfo ci2 = new CustomerInfo();
            ci2.CustomerId = "0022";
            ci2.BusinessId = "02";
            CustomerInfos cis = new CustomerInfos();
            cis.cs = new CustomerInfo[] { ci1, ci2 };

            config.CustomerInfos = cis;

            ScanConfigs sc = new ScanConfigs();
            sc.BeginTime = "22:00:00";
            sc.EndTimme = "23:00:00";

            config.ScanConfigs = sc;

            XmlUtil.SerializeToXml(config, config.GetType(), "d:\\config.xml", null);