分类

链接

2016 年 11 月
一 二 三 四 五 六 日
 123456
78910111213
14151617181920
21222324252627
282930  

近期文章

热门标签

新人福利，免费薅羊毛

现在位置:    首页 ＞ .NET ＞ 正文
共享办公室出租
C#.NET解析XML（使用属性控制 XML 序列化）
 2016-11-05 14:31 .NET 暂无评论 阅读(1,259)

今天需要解析一个XML，这个XML和一般情况用.NET的序列化出来的格式不太一样。

我就又补习了一下。

分享一下学习成果吧。

示例代码下载：

http://download.csdn.net/detail/bdstjk/4028340

先给大家看看基础知识吧，后面再给大家贴一个复杂实例

 

使用属性可以控制对象的 XML 序列化。

默认情况下，XML 元素名称由类或成员名称确定。在名为 Book 的简单类中，字段 ISBN 将生成 XML 元素标记 <ISBN>，如下面的示例所示。

[csharp] view plain copy

  1. public class Book
  2. {
  3.     public string ISBN;
  4. }
  5. // When an instance of the Book class is serialized, it might 
  6. // produce this XML:
  7. // <ISBN>1234567890</ISBN>.

若要重新命名元素，可以更改这种默认行为。下面的代码演示属性 (Attribute) 如何通过设置 XmlElementAttribute 的 ElementName 属性 (Property) 实现此目的。

[csharp] view plain copy

  1. public class TaxRates{
  2.     [XmlElement(ElementName = "TaxRate")]
  3.     public decimal ReturnTaxRate;
  4. }

 

XmlArrayAttribute 和 XmlArrayItemAttribute 属性旨在用于控制数组的序列化。使用这些属性可以控制元素名称、命名空间以及 XML 架构 (XSD) 数据类型（在万维网联合会 [www.w3.org] 文档“XML 架构第 2 部分：数据类型”中进行了定义）。此外，还可以指定数组所能包含的类型。

对于序列化数组时生成的封闭 XML 元素，其属性将由 XmlArrayAttribute 确定。例如，默认情况下，序列化下面的数组时，将会生成名为Employees 的 XML 元素。Employees 元素将包含在数组类型Employee 之后命名的一系列元素。

[csharp] view plain copy

  1. public class Group{
  2.     public Employee[] Employees;
  3. }
  4. public class Employee{
  5.     public string Name;
  6. }

序列化实例可能如下所示。

[html] view plain copy

  1. <Group>
  2. <Employees>
  3.     <Employee>
  4.         <Name>Haley</Name>
  5.     </Employee>
  6. </Employees >
  7. </Group>

 

通过应用 XmlArrayAttribute，可以按照以下方式更改 XML 元素的名称。

[csharp] view plain copy

  1. public class Group{
  2.     [XmlArray("TeamMembers")]
  3.     public Employee[] Employees;
  4. }

 

生成的 XML 可能如下所示。

[html] view plain copy

  1. <Group>
  2. <TeamMembers>
  3.     <Employee>
  4.         <Name>Haley</Name>
  5.     </Employee>
  6. </TeamMembers>

 

另一方面，XmlArrayItemAttribute 可以控制如何序列化数组中包含的项。请注意，该属性将应用于返回数组的字段。

[csharp] view plain copy

  1. public class Group{
  2.     [XmlArrayItem("MemberName")]
  3.     public Employee[] Employees;
  4. }

 

生成的 XML 可能如下所示。

[html] view plain copy

  1. <Group>
  2. <Employees>
  3.     <MemberName>Haley</MemberName>
  4. </Employees>
  5. </Group>

 

序列化派生类

XmlArrayItemAttribute 的另一种用法是，允许序列化派生类。例如，可将派生自 Employee 的另一个名为Manager 的类添加至上一示例中。如果没有应用XmlArrayItemAttribute，代码将在运行时失败，原因是无法识别派生类类型。若要解决这个问题，每次为每个可接受类型（基类和派生类）设置 Type 属性 (Property) 时，需要应用该属性 (Attribute) 两次。

[csharp] view plain copy

  1. public class Group{
  2.     [XmlArrayItem(Type = typeof(Employee)),
  3.     XmlArrayItem(Type = typeof(Manager))]
  4.     public Employee[] Employees;
  5. }
  6. public class Employee{
  7.     public string Name;
  8. }
  9. public class Manager:Employee{
  10.     public int Level;
  11. }

 

序列化实例可能如下所示。

[html] view plain copy

  1. <Group>
  2. <Employees>
  3.     <Employee>
  4.         <Name>Haley</Name>
  5.     </Employee>
  6.     <Employee xsi:type = "Manager">
  7.         <Name>Ann</Name>
  8.         <Level>3</Level>
  9.     <Employee>
  10. </Employees >
  11. </Group>

将数组作为元素序列进行序列化

通过将 XmlElementAttribute 应用于返回数组的字段，还可以将该数组作为 XML 元素的平面序列进行序列化，如下所示。

[csharp] view plain copy

  1. public class Group{
  2.     [XmlElement]
  3.     public Employee[] Employees;
  4. }

 

序列化实例可能如下所示。

[html] view plain copy

  1. <Group>
  2. <Employees>
  3.     <Name>Haley</Name>
  4. </Employees>
  5. <Employees>
  6.     <Name>Noriko</Name>
  7. </Employees>
  8. <Employees>
  9.     <Name>Marco</Name>
  10. </Employees>
  11. </Group>

 

区别两种 XML 流的另一个方法是，使用 XML 架构定义工具，从编译好的代码生成 XML 架构 (XSD) 文档文件。没有将属性应用于字段时，架构会以下列方式描述元素。

<xs:element minOccurs="0" maxOccurs ="1" name="Employees" type="ArrayOfEmployee" />

将 XmlElementAttribute 应用于字段时，生成的架构会以下列方式描述元素。

<xs:element minOccurs="0" maxOccurs="unbounded" name="Employees" type="Employee" />

序列化 ArrayList

ArrayList 类可能包含各种不同对象的集合。因此，可以按照使用数组的类似方式使用 ArrayList。您可以创建返回单个ArrayList 的字段，而不用创建返回类型化对象的数组的字段。但是，与数组相同的是，必须将ArrayList 包含的对象的类型告知 XmlSerializer。为此，需要为该字段分配XmlElementAttribute 的多个实例，如下面的示例所示。

[csharp] view plain copy

  1. public class Group{
  2.     [XmlElement(Type = typeof(Employee)),
  3.     XmlElement(Type = typeof(Manager))]
  4.     public ArrayList Info;
  5. }

 

使用 XmlRootAttribute 和 XmlTypeAttribute 控制类的序列化

能且只能应用于一个类的属性有下面两种：XmlRootAttribute 和 XmlTypeAttribute。这两种属性非常相似。XmlRootAttribute 只能应用于一个类：序列化时，该类表示 XML 文档的开始和结束元素，也就是根元素。另一方面，XmlTypeAttribute 可以应用于任何一个类，包括根类。

例如，在上面的示例中，Group 类就是根类，而其所有的公共字段和属性变成 XML 文档中的 XML 元素。因此，只能有一个根类。通过应用XmlRootAttribute，可以控制XmlSerializer 所生成的 XML 流。例如，可以更改元素名称和命名空间。

使用 XmlTypeAttribute 可以控制所生成 XML 的架构。需要通过 XML Web services 发布架构时，这项功能很有用。下面的示例将XmlTypeAttribute 和XmlRootAttribute 同时应用于同一个类。

[csharp] view plain copy

  1. [XmlRoot("NewGroupName")]
  2. [XmlType("NewTypeName")]
  3. public class Group{
  4.     public Employee[] Employees;
  5. }

 

如果对该类进行编译，并且使用 XML 架构定义工具生成其架构，可能会找到下面描述 Group 的 XML。

<xs:element name="NewGroupName" type="NewTypeName">

 

相比之下，如果是对该类的实例进行序列化，则只能在 XML 文档中找到 NewGroupName。

<NewGroupName> . . .</NewGroupName>

 

 

最后来贴一个自己的XML解析实例

XML结构如下：

[html] view plain copy

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Root>
  3.     <Person IDCard="610424199902230099" Name="小田雨" MedicalID="体检编号" Sex="男" Age="22" MedicalRecordDate ="2011-01-01"  MedicalReportDate="2011-01-01"
  4.   MedicalCount="体检次数"  HospitalID="001" HospitalName="兴隆园医院" >
  5.         <Results>
  6.             <Result></Result>
  7.             <Result></Result>
  8.             <Result></Result>
  9.         </Results>
  10.         <Conclusions>
  11.             <Conclusion></Conclusion>
  12.             <Conclusion></Conclusion>
  13.             <Conclusion></Conclusion>
  14.         </Conclusions>
  15.         <Suggestions>
  16.             <Suggestion></Suggestion>
  17.             <Suggestion></Suggestion>
  18.             <Suggestion></Suggestion>
  19.         </Suggestions>
  20.         <Health> 为空（预留）</Health>
  21.     </Person>
  23.     <MedicalItems>
  24.         <MedicalSub  ID ="0001" Name="化学检查"  >
  25.             <MedicalType ID ="0001001" Name="血常规" MedicalDoc="体检医师名字" MedicalDate="2011-02-13">
  27.                 <Item ID="000100010001" Name="白细胞" Unit="G/L" Parameters="3.7--10.0" >
  28.                     <Results>H==高，L=低，N=正常</Results>
  29.                     <Value>11.1</Value>
  30.                     <Disease></Disease>
  31.                     <MedicalBodyPart> </MedicalBodyPart>
  32.                     <MedicalImage> </MedicalImage>
  33.                     <Conclusion ></Conclusion>
  34.                 </Item>
  35.                 <Item ID="000100010002" Name="红细胞" Unit="G/L" Parameters="3.7--10.0">
  36.                     <Results>H==高，L=低，N=正常</Results>
  37.                     <Value>11.1</Value>
  38.                     <Disease></Disease>
  39.                     <MedicalBodyPart> </MedicalBodyPart>
  40.                     <MedicalImage> </MedicalImage>
  41.                     <Conclusion ></Conclusion>
  42.                 </Item>
  43.             </MedicalType>
  44.         </MedicalSub>
  45.         <MedicalSub  ID ="0002" Name="物理检查"  >
  46.             <MedicalType ID ="0002001" Name="B超" MedicalDoc="体检医师名字" MedicalDate="2011-02-13">
  47.                 <Item ID="000200010001" Name="胸部B超" Unit=" " Parameters="">
  48.                     <Results>A=异常，N=正常</Results>
  49.                     <Value></Value>
  50.                     <Disease>病种，未见异常</Disease>
  51.                     <MedicalBodyPart>检查部位：胸部</MedicalBodyPart>
  52.                     <MedicalImage>影像所见</MedicalImage>
  53.                     <Conclusion >检查结论</Conclusion>
  54.                 </Item>
  55.                 <Item ID="000200010002" Name="腹部B超" Unit=" " Parameters="">
  56.                     <Results>A=异常，N=正常</Results>
  57.                     <Value></Value>
  58.                     <Disease>病种，未见异常</Disease>
  59.                     <MedicalBodyPart>检查部位：腹部</MedicalBodyPart>
  60.                     <MedicalImage>影像所见</MedicalImage>
  61.                     <Conclusion >检查结论</Conclusion>
  62.                 </Item>
  63.             </MedicalType>
  65.         </MedicalSub>
  66.         <MedicalSub  ID ="0005" Name="五官科"  >
  67.             <MedicalType ID ="0005001" Name="眼科" MedicalDoc="体检医师名字" MedicalDate="2011-02-13">
  68.                 <Item ID="000500010001" Name="视力/右" Unit=" " Parameters="1.0-1.5">
  69.                     <Results>A=异常，N=正常</Results>
  70.                     <Value>1.5</Value>
  71.                     <Disease>病种，未见异常</Disease>
  72.                     <MedicalBodyPart>检查部位</MedicalBodyPart>
  73.                     <MedicalImage>影像所见</MedicalImage>
  74.                     <Conclusion >检查结论</Conclusion>
  75.                 </Item>
  76.                 <Item ID="000500010002" Name="矫正视力/右" Unit=" " Parameters="1.0-1.5">
  77.                     <Results>A=异常，N=正常</Results>
  78.                     <Value>0.8</Value>
  79.                     <Disease>病种，未见异常</Disease>
  80.                     <MedicalBodyPart>检查部位</MedicalBodyPart>
  81.                     <MedicalImage>影像所见</MedicalImage>
  82.                     <Conclusion >检查结论</Conclusion>
  83.                 </Item>
  84.             </MedicalType>
  86.         </MedicalSub>
  87.     </MedicalItems>
  88. </Root>

 

 

实例

C#代码如下：

代码有点多

[csharp] view plain copy

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Xml;
  6. using System.Xml.Serialization;
  7. using System.IO;
  8. namespace 天健接口
  9. {
  10.     class Program
  11.     {
  12.         static void Main(string[] args)
  13.         {
  14.             Root r = new Root();
  15.             r.Person = new Person();
  16.             r.Person.IDCard = "22";
  17.             r.Person.Results = new List<string>();
  18.             r.Person.Results.Add("1");
  19.             r.Person.Results.Add("1");
  20.             r.Person.Results.Add("1");
  21.             r.Person.Suggestions = new List<string>();
  22.             r.Person.Suggestions.Add("2");
  23.             r.Person.Suggestions.Add("2");
  24.             r.Person.Suggestions.Add("2");
  25.             r.MedicalItems = new List<MedicalSub>();
  26.             MedicalSub ms = new MedicalSub();
  27.             ms.ID = "ss";
  28.             ms.Name="de";
  29.             ms.MedicalType = new MedicalType();
  30.             ms.MedicalType.ID = "wa";
  31.             ms.MedicalType.Name = "s";
  32.             ms.MedicalType.MedicalDoc= "qa";
  33.             ms.MedicalType.MedicalDate = "2010-5-5";
  34.             ms.MedicalType.Item = new List<Item>();
  35.             Item it = new Item();
  36.             it.ID = "f";
  37.             it.Name = "s";
  38.             it.Results = "s";
  39.             ms.MedicalType.Item.Add(it);
  40.             ms.MedicalType.Item.Add(it);
  41.             r.MedicalItems.Add(ms);
  42.             r.MedicalItems.Add(ms);
  43.             Console.WriteLine("序列化成功……");
  44.             Console.WriteLine(XmlSerialize.SerializeXML<Root>(r));
  45.         }
  46.     }
  47.     [Serializable]
  48.     public class Root
  49.     {
  50.         //[XmlElement]
  51.         public Person Person;
  52.         public List<MedicalSub> MedicalItems;
  53.     }
  54.     [Serializable]
  55.     public class Person
  56.     {
  57.         [XmlAttribute]
  58.         public string IDCard;
  59.         [XmlAttribute]
  60.         public string Name;
  61.         [XmlAttribute]
  62.         public string MedicalID;
  63.         [XmlAttribute]
  64.         public string Sex;
  65.         [XmlAttribute]
  66.         public string Age;
  67.         [XmlAttribute]
  68.         public string MedicalRecordDate;
  69.         [XmlAttribute]
  70.         public string MedicalReportDate;
  71.         [XmlAttribute]
  72.         public string MedicalCount;
  73.         [XmlAttribute]
  74.         public string HospitalID;
  75.         [XmlAttribute]
  76.         public string HospitalName;
  77.         [XmlArrayItem("Result")]
  78.         public List<string> Results;
  79.         [XmlArrayItem("Conclusion")]
  80.         public List<string> Conclusions;
  81.         [XmlArrayItem("Suggestion")]
  82.         public List<string> Suggestions;
  83.         public String Health;
  84.     }
  85.     [Serializable]
  86.     public class MedicalSub
  87.     {
  88.         [XmlAttribute]
  89.         public string ID;
  90.         [XmlAttribute]
  91.         public string Name;
  92.         public MedicalType MedicalType;
  93.     }
  94.     [Serializable]
  95.     public class MedicalType
  96.     {
  97.         [XmlAttribute]
  98.         public string ID;
  99.         [XmlAttribute]
  100.         public string Name;
  101.         [XmlAttribute]
  102.         public string MedicalDoc;
  103.         [XmlAttribute]
  104.         public string MedicalDate;
  105.         [XmlElement]
  106.         public List<Item> Item;
  107.     }
  108.     public class Item
  109.     {
  110.         [XmlAttribute]
  111.         public string ID;
  112.         [XmlAttribute]
  113.         public string Name;
  114.         [XmlAttribute]
  115.         public string Unit;
  116.         [XmlAttribute]
  117.         public string Parameters;
  118.         public string Results;
  119.         public string Value;
  120.         public string Disease;
  121.         public string MedicalBodyPart;
  122.         public string MedicalImage;
  123.         public string Conclusion;
  124.     }
  125.     public class XmlSerialize
  126.     {
  127.         /// <summary>
  128.         /// 反序列化XML为类实例
  129.         /// </summary>
  130.         /// <typeparam name="T"></typeparam>
  131.         /// <param name="xmlObj"></param>
  132.         /// <returns></returns>
  133.         public static T DeserializeXML<T>(string xmlObj)
  134.         {
  135.             XmlSerializer serializer = new XmlSerializer(typeof(T));
  136.             using (StringReader reader = new StringReader(xmlObj))
  137.             {
  138.                 return (T)serializer.Deserialize(reader);
  139.             }
  140.         }
  141.         /// <summary>
  142.         /// 序列化类实例为XML
  143.         /// </summary>
  144.         /// <typeparam name="T"></typeparam>
  145.         /// <param name="obj"></param>
  146.         /// <returns></returns>
  147.         public static string SerializeXML<T>(T obj)
  148.         {
  149.             using (StringWriter writer = new StringWriter())
  150.             {
  151.                 new XmlSerializer(obj.GetType()).Serialize((TextWriter)writer, obj);
  152.                 return writer.ToString();
  153.             }
  154.         }
  155.     }
  156. }

============ 欢迎各位老板打赏~ ===========

关键字: , ,
【上篇】
【下篇】

与本文相关的文章

该日志由 Bruce 于2016年11月05日发表在.NET分类下

本文版权归Bruce's Blog所有，转载引用请完整注明以下信息：
本文作者：Bruce
本文地址：C#.NET解析XML（使用属性控制 XML 序列化） | Bruce's Blog

发表评论

留言无头像?