C#实体类与XML相互转换

男娘i 2021-09-16 13:48 489阅读 0赞

1、实体类与XML相互转换

将实体类转换成XML需要使用XmlSerializer类的Serialize方法，将实体类序列化。

把XML转换成相应的实体类，需要使用到XmlSerializer类的Deserialize方法，将XML进行反序列化。

创建XML序列化公共处理类（XmlSerializeHelper.cs）

  1. using System;
  2. using System.IO;
  3. using System.Xml.Serialization;
  5. /// <summary>
  6. /// XML序列化公共处理类
  7. /// </summary>
  8. public static class XmlSerializeHelper
  9. {
  10.     /// <summary>
  11.     /// 将实体对象转换成XML
  12.     /// </summary>
  13.     /// <typeparam name="T">实体类型</typeparam>
  14.     /// <param name="obj">实体对象</param>
  15.     public static string XmlSerialize<T>(T obj)
  16.     {
  17.         try
  18.         {
  19.             using (StringWriter sw = new StringWriter())
  20.             {
  21.                 Type t = obj.GetType();
  22.                 XmlSerializer serializer = new XmlSerializer(obj.GetType());
  23.                 serializer.Serialize(sw, obj);
  24.                 sw.Close();
  25.                 return sw.ToString();
  26.             }
  27.         }
  28.         catch (Exception ex)
  29.         {
  30.             throw new Exception("将实体对象转换成XML异常", ex);
  31.         }
  32.     }
  34.     /// <summary>
  35.     /// 将XML转换成实体对象
  36.     /// </summary>
  37.     /// <typeparam name="T">实体类型</typeparam>
  38.     /// <param name="strXML">XML</param>
  39.     public static T DESerializer<T>(string strXML) where T : class
  40.     {
  41.         try
  42.         {
  43.             using (StringReader sr = new StringReader(strXML))
  44.             {
  45.                 XmlSerializer serializer = new XmlSerializer(typeof(T));
  46.                 return serializer.Deserialize(sr) as T;
  47.             }
  48.         }
  49.         catch (Exception ex)
  50.         {
  51.             throw new Exception("将XML转换成实体对象异常", ex);
  52.         }
  53.     }
  54. }

创建用户信息类，用于示例使用。

  1. /// <summary>
  2. /// 用户信息类
  3. /// </summary>
  4. public class UserInfo
  5. {
  6.     /// <summary>
  7.     /// 编号
  8.     /// </summary>
  9.     public int ID { get; set; }
  11.     /// <summary>
  12.     /// 名称
  13.     /// </summary>
  14.     public string Name { get; set; }
  16.     /// <summary>
  17.     /// 创建时间
  18.     /// </summary>
  19.     public DateTime? CreateTime { get; set; }
  20. }

1.1 示例1：将List与XML相互转换

  1. /// <summary>
  2. /// 将List与XML相互转换
  3. /// </summary>
  4. public static void ListToXmlTest()
  5. {
  6.     //获取用户列表
  7.     List<UserInfo> userList = GetUserList();
  9.     //将实体对象转换成XML
  10.     string xmlResult = XmlSerializeHelper.XmlSerialize(userList);
  12.     //将XML转换成实体对象
  13.     List<UserInfo> deResult = XmlSerializeHelper.DESerializer<List<UserInfo>>(xmlResult);
  14. }
  16. /// <summary>
  17. /// 获取用户信息列表
  18. /// </summary>
  19. public static List<UserInfo> GetUserList()
  20. {
  21.     List<UserInfo> userList = new List<UserInfo>();
  22.     userList.Add(new UserInfo() { ID = 1, Name = "张三", CreateTime = DateTime.Now });
  23.     userList.Add(new UserInfo() { ID = 2, Name = "李四", CreateTime = DateTime.Now });
  24.     userList.Add(new UserInfo() { ID = 2, Name = "王五" });
  25.     return userList;
  26. }

XML结果：

  1. <?xml version="1.0" encoding="utf-16"?>
  2. <ArrayOfUserInfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  3.   <UserInfo>
  4.     <ID>1</ID>
  5.     <Name>张三</Name>
  6.     <CreateTime>2018-10-04T15:59:53.7761027+08:00</CreateTime>
  7.   </UserInfo>
  8.   <UserInfo>
  9.     <ID>2</ID>
  10.     <Name>李四</Name>
  11.     <CreateTime>2018-10-04T15:59:54.9571044+08:00</CreateTime>
  12.   </UserInfo>
  13.   <UserInfo>
  14.     <ID>2</ID>
  15.     <Name>王五</Name>
  16.     <CreateTime xsi:nil="true" />
  17.   </UserInfo>
  18. </ArrayOfUserInfo>

1.2 示例2：将DataTable与XML相互转换

  1. /// <summary>
  2. /// 将DataTable与XML相互转换
  3. /// </summary>
  4. public static void DataTableToXmlTest()
  5. {
  6.     //创建DataTable对象
  7.     DataTable dt = CreateDataTable();
  9.     //将DataTable转换成XML
  10.     string xmlResult = XmlSerializeHelper.XmlSerialize(dt);
  12.     //将XML转换成DataTable
  13.     DataTable deResult = XmlSerializeHelper.DESerializer<DataTable>(xmlResult);
  14. }
  16. /// <summary>
  17. /// 创建DataTable对象
  18. /// </summary>
  19. public static DataTable CreateDataTable()
  20. {
  21.     //创建DataTable
  22.     DataTable dt = new DataTable("NewDt");
  24.     //创建自增长的ID列
  25.     DataColumn dc = dt.Columns.Add("ID", Type.GetType("System.Int32"));
  26.     dt.Columns.Add(new DataColumn("Name", Type.GetType("System.String")));
  27.     dt.Columns.Add(new DataColumn("CreateTime", Type.GetType("System.DateTime")));
  29.     //创建数据
  30.     DataRow dr = dt.NewRow();
  31.     dr["ID"] = 1;
  32.     dr["Name"] = "张三";
  33.     dr["CreateTime"] = DateTime.Now;
  34.     dt.Rows.Add(dr);
  36.     dr = dt.NewRow();
  37.     dr["ID"] = 2;
  38.     dr["Name"] = "李四";
  39.     dr["CreateTime"] = DateTime.Now;
  40.     dt.Rows.Add(dr);
  42.     dr = dt.NewRow();
  43.     dr["ID"] = 3;
  44.     dr["Name"] = "王五";
  45.     dr["CreateTime"] = DateTime.Now;
  46.     dt.Rows.Add(dr);
  48.     return dt;
  49. }

XML结果：

  1. <?xml version="1.0" encoding="utf-16"?>
  2. <DataTable>
  3.   <xs:schema id="NewDataSet" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
  4.     <xs:element name="NewDataSet" msdata:IsDataSet="true" msdata:MainDataTable="NewDt" msdata:UseCurrentLocale="true">
  5.       <xs:complexType>
  6.         <xs:choice minOccurs="0" maxOccurs="unbounded">
  7.           <xs:element name="NewDt">
  8.             <xs:complexType>
  9.               <xs:sequence>
  10.                 <xs:element name="ID" type="xs:int" minOccurs="0" />
  11.                 <xs:element name="Name" type="xs:string" minOccurs="0" />
  12.                 <xs:element name="CreateTime" type="xs:dateTime" minOccurs="0" />
  13.               </xs:sequence>
  14.             </xs:complexType>
  15.           </xs:element>
  16.         </xs:choice>
  17.       </xs:complexType>
  18.     </xs:element>
  19.   </xs:schema>
  20.   <diffgr:diffgram xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" xmlns:diffgr="urn:schemas-microsoft-com:xml-diffgram-v1">
  21.     <DocumentElement>
  22.       <NewDt diffgr:id="NewDt1" msdata:rowOrder="0" diffgr:hasChanges="inserted">
  23.         <ID>1</ID>
  24.         <Name>张三</Name>
  25.         <CreateTime>2018-10-04T16:06:10.8004082+08:00</CreateTime>
  26.       </NewDt>
  27.       <NewDt diffgr:id="NewDt2" msdata:rowOrder="1" diffgr:hasChanges="inserted">
  28.         <ID>2</ID>
  29.         <Name>李四</Name>
  30.         <CreateTime>2018-10-04T16:06:10.8004082+08:00</CreateTime>
  31.       </NewDt>
  32.       <NewDt diffgr:id="NewDt3" msdata:rowOrder="2" diffgr:hasChanges="inserted">
  33.         <ID>3</ID>
  34.         <Name>王五</Name>
  35.         <CreateTime>2018-10-04T16:06:10.8004082+08:00</CreateTime>
  36.       </NewDt>
  37.     </DocumentElement>
  38.   </diffgr:diffgram>
  39. </DataTable>

2、序列化常用Attribute讲解说明

[XmlRootAttribute(“MyCity”, Namespace=”abc.abc”, IsNullable=false)] // 当该类为Xml根节点时，以此为根节点名称。
public class City

[XmlAttribute(“AreaName”)] // 表现为Xml节点属性。<… AreaName=”…”/>
public string Name

[XmlElementAttribute(“AreaId”, IsNullable = false)] // 表现为Xml节点。…
public string Id

[XmlArrayAttribute(“Areas”)] // 表现为Xml层次结构，根为Areas，其所属的每个该集合节点元素名为类名。
public Area[] Areas

[XmlElementAttribute(“Area”, IsNullable = false)] // 表现为水平结构的Xml节点。…
public Area[] Areas

[XmlIgnoreAttribute] // 忽略该元素的序列化。

把这些属性与model类的相关属性，配合使用，就可以自由设置相关XML的具体格式了。

综合示例：将班级信息序列化成XML

示例要求：

（1）每个XML节点以“My”开头。

（2）班级ID和学生ID字段以XML节点属性表现，其它字段以XML节点的形式表现。

（3）由于学生的邮箱涉及敏感信息，所以不参与序列化。

2.1 创建班级信息类（ClassInfo.cs）

  1. using System.Collections.Generic;
  2. using System.Xml.Serialization;
  4. /// <summary>
  5. /// 班级信息类
  6. /// </summary>
  7. [XmlRootAttribute("MyClassInfo", Namespace = "ABC_123", IsNullable = false)] 
  8. public class ClassInfo
  9. {
  10.     /// <summary>
  11.     /// 班级ID
  12.     /// </summary>
  13.     [XmlAttribute("MyClassID")]
  14.     public int ClassID { get; set; }
  16.     /// <summary>
  17.     /// 班级名称
  18.     /// </summary>
  19.     [XmlElementAttribute("MyClassName", IsNullable = false)] 
  20.     public string ClassName { get; set; }
  22.     /// <summary>
  23.     /// 班长人
  24.     /// </summary>
  25.     [XmlElementAttribute("MyTeacher", IsNullable = false)] 
  26.     public string Teacher { get; set; }
  28.     /// <summary>
  29.     /// 学生列表
  30.     /// </summary>
  31.     [XmlArrayAttribute("MyStudents")]  
  32.     public List<Student> StudentList { get; set; }
  33. }

2.2 创建学生信息类（Student.cs）

  1. using System.Xml.Serialization;
  3. /// <summary>
  4. /// 学生信息类
  5. /// </summary>
  6. [XmlRootAttribute("MyStudent", IsNullable = false)] 
  7. public class Student
  8. {
  9.     /// <summary>
  10.     /// 学生ID
  11.     /// </summary>
  12.     [XmlAttribute("MyStuID")]
  13.     public int StuID { get; set; }
  15.     /// <summary>
  16.     /// 学生名称
  17.     /// </summary>
  18.     [XmlElementAttribute("MyStuName", IsNullable = false)] 
  19.     public string StuName { get; set; }
  21.     /// <summary>
  22.     /// 性别
  23.     /// </summary>
  24.     [XmlElementAttribute("MySex", IsNullable = false)] 
  25.     public string Sex { get; set; }
  27.     /// <summary>
  28.     /// 邮箱
  29.     /// </summary>
  30.     [XmlIgnoreAttribute] 
  31.     public string Email { get; set; }
  32. }

2.3 将班级信息转换成XML

  1. /// <summary>
  2. /// 将班级信息转换成XML
  3. /// </summary>
  4. public static void ClassInfoToXml()
  5. {
  6.     //获取班级信息
  7.     ClassInfo classInfo = GetClassInfo();
  9.     //将班级信息转换成XML
  10.     string classXml = XmlSerializeHelper.XmlSerialize(classInfo);
  11. }
  13. /// <summary>
  14. /// 获取班级信息
  15. /// </summary>
  16. public static ClassInfo GetClassInfo()
  17. {
  18.     //创建班级信息
  19.     ClassInfo classInfo = new ClassInfo();
  20.     classInfo.ClassID = 1;
  21.     classInfo.ClassName = "高一（5）班";
  22.     classInfo.Teacher = "李老师";
  24.     //创建学生列表
  25.     List<Student> studentList = new List<Student>();
  26.     studentList.Add(new Student() { StuID = 1, StuName = "张三", Sex = "男", Email = "zhangsan@mail.com" });
  27.     studentList.Add(new Student() { StuID = 2, StuName = "李四", Sex = "女", Email = "lisi@mail.com" });
  28.     studentList.Add(new Student() { StuID = 3, StuName = "王五", Sex = "男", Email = "wangwu@mail.com" });
  29.     classInfo.StudentList = studentList;
  31.     return classInfo;
  32. }

XML结果：

  1. <?xml version="1.0" encoding="utf-16"?>
  2. <MyClassInfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" MyClassID="1" xmlns="ABC_123">
  3.   <MyClassName>高一（5）班</MyClassName>
  4.   <MyTeacher>李老师</MyTeacher>
  5.   <MyStudents>
  6.     <Student MyStuID="1">
  7.       <MyStuName>张三</MyStuName>
  8.       <MySex>男</MySex>
  9.     </Student>
  10.     <Student MyStuID="2">
  11.       <MyStuName>李四</MyStuName>
  12.       <MySex>女</MySex>
  13.     </Student>
  14.     <Student MyStuID="3">
  15.       <MyStuName>王五</MyStuName>
  16.       <MySex>男</MySex>
  17.     </Student>
  18.   </MyStudents>
  19. </MyClassInfo>

发表评论

表情：
评论列表 （有 0 条评论，489人围观）

还没有评论，来说两句吧...

相关阅读

    相关 C#实体类与XML相互转换

    1、实体类与XML相互转换 将实体类转换成XML需要使用XmlSerializer类的Serialize方法，将实体类序列化。 把XML转换成相应的实体类，需要使用到Xml

    男娘i男娘i/ 0 赞/ 490 阅读