C#实现实体类和XML相互转换

一、实体类转换成XML

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

public static string XmlSerialize<T>(T obj)
{
       using (StringWriter sw = new StringWriter())
       {
             Type t= obj.GetType();             
             XmlSerializer serializer = new XmlSerializer(obj.GetType());
             serializer.Serialize(sw, obj);
             sw.Close();
             return sw.ToString();
        }
}      

示例：

1、定义实体类

1     [System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)]
 2     [System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)]
 3     public class Request
 4     {
 5 
 6         public string System { get; set; }
 7         public string SecurityCode { get; set; }
 8         public PatientBasicInfo PatientInfo { get; set; }      
 9     }
10 
11     /// <remarks/>
12     [System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)]
13     public partial class PatientBasicInfo
14     {
15         public string PatientNo { get; set; }
16         public string PatientName { get; set; }
17         public string Phoneticize { get; set; }
18         public string Sex { get; set; }
19         public string Birth { get; set; }
20         public string BirthPlace { get; set; }
21         public string Country { get; set; }
22         public string Nation { get; set; }
23         public string IDNumber { get; set; }
24         public string SecurityNo { get; set; }
25         public string Workunits { get; set; }
26         public string Address { get; set; }
27         public string ZIPCode { get; set; }
28         public string Phone { get; set; }
29         public string ContactPerson { get; set; }
30         public string ContactShip { get; set; }
31         public string ContactPersonAdd { get; set; }
32         public string ContactPersonPhone { get; set; }
33         public string OperationCode { get; set; }
34         public string OperationName { get; set; }
35         public string OperationTime { get; set; }
36         public string CardNo { get; set; }
37         public string ChangeType { get; set; }
38 
39     }      

2、给实体类赋值，并通过序列化将实体类转换成XML格式的字符串

1 Request patientIn = new Request();
 2             patientIn.System = "HIS";
 3             patientIn.SecurityCode = "HIS5";
 4 
 5             PatientBasicInfo basicInfo = new PatientBasicInfo();
 6             basicInfo.PatientNo = "1234";
 7             basicInfo.PatientName = "测试";
 8             basicInfo.Phoneticize = "";
 9             basicInfo.Sex = "1";
10             basicInfo.Birth = "";
11             basicInfo.BirthPlace = "";
12             basicInfo.Country = "";
13             basicInfo.Nation = "";
14             basicInfo.IDNumber = "";
15             basicInfo.SecurityNo = "";
16             basicInfo.Workunits = "";
17             basicInfo.Address = "";
18             basicInfo.ZIPCode = "";
19             basicInfo.Phone = "";
20             basicInfo.ContactShip = "";
21             basicInfo.ContactPersonPhone = "";
22             basicInfo.ContactPersonAdd = "";
23             basicInfo.ContactPerson = "";
24             basicInfo.ChangeType = "";
25             basicInfo.CardNo = "";
26             basicInfo.OperationCode = "";
27             basicInfo.OperationName = "";
28             basicInfo.OperationTime = "";
29 
30             patientIn.PatientInfo = basicInfo;
31 
32             //序列化
33             string strxml = XmlSerializeHelper.XmlSerialize<Request>(patientIn);      

3、生成的XML实例

1 <?xml version="1.0" encoding="utf-16"?>
 2 <Request xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 3   <System>HIS</System>
 4   <SecurityCode>HIS5</SecurityCode>
 5   <PatientInfo>
 6     <PatientNo>1234</PatientNo>
 7     <PatientName>测试</PatientName>
 8     <Phoneticize />
 9     <Sex>1</Sex>
10     <Birth />
11     <BirthPlace />
12     <Country />
13     <Nation />
14     <IDNumber />
15     <SecurityNo />
16     <Workunits />
17     <Address />
18     <ZIPCode />
19     <Phone />
20     <ContactPerson />
21     <ContactShip />
22     <ContactPersonAdd />
23     <ContactPersonPhone />
24     <OperationCode />
25     <OperationName />
26     <OperationTime />
27     <CardNo />
28     <ChangeType />
29   </PatientInfo>
30 </Request>      

二、将XML转换成实体类

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

1 public static T DESerializer<T>(string strXML) where T:class
 2 {
 3      try
 4     {
 5             using (StringReader sr = new StringReader(strXML))
 6            {
 7                 XmlSerializer serializer = new XmlSerializer(typeof(T));
 8                 return serializer.Deserialize(sr) as T;
 9            }
10      }
11      catch (Exception ex)
12      {
13             return null;
14      }
15 }      

示例：

将上例中序列化后的XML反序列化成实体类

1 //反序列化
2 Request r = XmlSerializeHelper.DESerializer<Request>(strxml);      

 三、将DataTable转换成XML

1  //将DataTable转换成XML
 2 DataTable dt = new DataTable("MyTable");
 3 //添加列
 4 dt.Columns.Add("Id", typeof(int));
 5 dt.Columns.Add("Name", typeof(string));
 6 dt.Columns.Add("Sex", typeof(char));
 7 //添加行
 8 dt.Rows.Add(1, "小明", '1');
 9 dt.Rows.Add(2, "小红", '2');
10 dt.Rows.Add(3, "小王", '2');
11 dt.Rows.Add(4, "测试", '2');
12 //序列化，将DataTable转换成XML格式的字符串
13 string strXML = XmlSerializeHelper.XmlSerialize <DataTable> (dt);      

四、将XML转换成DataTable

1 //反序列化，将XML转换成字符串
2 DataTable dtNew=  XmlSerializeHelper.DESerializer<DataTable>(strXML);      

五、将List集合转换成XML

/// <summary>
/// 测试类
/// </summary>
public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public char Sex { get; set; }
    public int Age { get; set; }
}

//测试集合
List<Student> list = new List<Student>()
{
        new Student(){Id=1,Name="小红",Sex='2',Age=20},
        new Student(){Id=2,Name="小明",Sex='1',Age=22},
        new Student(){Id=3,Name="小王",Sex='1',Age=19},
        new Student(){Id=4,Name="测试",Sex='2',Age=23}
};
//序列化
string strXML = XmlSerializeHelper.XmlSerialize<List<Student>>(list);      

六、将XML转换成集合

使用上面例子中集合转换成的XML进行反序列化。

1 //反序列化
2 List<Student> listStu = XmlSerializeHelper.DESerializer<List<Student>>(strXML);      

//**************************************

1、实体类与XML相互转换

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

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

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

1. using System;

2. using System.IO;

3. using System.Xml.Serialization;

4. /// <summary>

5. /// XML序列化公共处理类

6. /// </summary>

7. public static class XmlSerializeHelper

8. {

9. /// <summary>

10. /// 将实体对象转换成XML

11. /// </summary>

12. /// <typeparam name="T">实体类型</typeparam>

13. /// <param name="obj">实体对象</param>

14. public static string XmlSerialize<T>(T obj)

15. {

16. try

17. {

18. using (StringWriter sw = new StringWriter())

19. {

20. Type t = obj.GetType();

21. XmlSerializer serializer = new XmlSerializer(obj.GetType());

22. serializer.Serialize(sw, obj);

23. sw.Close();

24. return sw.ToString();

25. }

26. }

27. catch (Exception ex)

28. {

29. throw new Exception("将实体对象转换成XML异常", ex);

30. }

31. }

32. /// <summary>

33. /// 将XML转换成实体对象

34. /// </summary>

35. /// <typeparam name="T">实体类型</typeparam>

36. /// <param name="strXML">XML</param>

37. public static T DESerializer<T>(string strXML) where T : class

38. {

39. try

40. {

41. using (StringReader sr = new StringReader(strXML))

42. {

43. XmlSerializer serializer = new XmlSerializer(typeof(T));

44. return serializer.Deserialize(sr) as T;

45. }

46. }

47. catch (Exception ex)

48. {

49. throw new Exception("将XML转换成实体对象异常", ex);

50. }

51. }

52. }

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

1. /// <summary>

2. /// 用户信息类

3. /// </summary>

4. public class UserInfo

5. {

6. /// <summary>

7. /// 编号

8. /// </summary>

9. public int ID { get; set; }

10. /// <summary>

11. /// 名称

12. /// </summary>

13. public string Name { get; set; }

14. /// <summary>

15. /// 创建时间

16. /// </summary>

17. public DateTime? CreateTime { get; set; }

18. }

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

1. /// <summary>

2. /// 将List与XML相互转换

3. /// </summary>

4. public static void ListToXmlTest()

5. {

6. //获取用户列表

7. List<UserInfo> userList = GetUserList();

8. //将实体对象转换成XML

9. string xmlResult = XmlSerializeHelper.XmlSerialize(userList);

10. //将XML转换成实体对象

11. List<UserInfo> deResult = XmlSerializeHelper.DESerializer<List<UserInfo>>(xmlResult);

12. }

13. /// <summary>

14. /// 获取用户信息列表

15. /// </summary>

16. public static List<UserInfo> GetUserList()

17. {

18. List<UserInfo> userList = new List<UserInfo>();

19. userList.Add(new UserInfo() { ID = 1, Name = "张三", CreateTime = DateTime.Now });

20. userList.Add(new UserInfo() { ID = 2, Name = "李四", CreateTime = DateTime.Now });

21. userList.Add(new UserInfo() { ID = 2, Name = "王五" });

22. return userList;

23. }

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();

8. //将DataTable转换成XML

9. string xmlResult = XmlSerializeHelper.XmlSerialize(dt);

10. //将XML转换成DataTable

11. DataTable deResult = XmlSerializeHelper.DESerializer<DataTable>(xmlResult);

12. }

13. /// <summary>

14. /// 创建DataTable对象

15. /// </summary>

16. public static DataTable CreateDataTable()

17. {

18. //创建DataTable

19. DataTable dt = new DataTable("NewDt");

20. //创建自增长的ID列

21. DataColumn dc = dt.Columns.Add("ID", Type.GetType("System.Int32"));

22. dt.Columns.Add(new DataColumn("Name", Type.GetType("System.String")));

23. dt.Columns.Add(new DataColumn("CreateTime", Type.GetType("System.DateTime")));

24. //创建数据

25. DataRow dr = dt.NewRow();

26. dr["ID"] = 1;

27. dr["Name"] = "张三";

28. dr["CreateTime"] = DateTime.Now;

29. dt.Rows.Add(dr);

30. dr = dt.NewRow();

31. dr["ID"] = 2;

32. dr["Name"] = "李四";

33. dr["CreateTime"] = DateTime.Now;

34. dt.Rows.Add(dr);

35. dr = dt.NewRow();

36. dr["ID"] = 3;

37. dr["Name"] = "王五";

38. dr["CreateTime"] = DateTime.Now;

39. dt.Rows.Add(dr);

40. return dt;

41. }

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节点。<AreaId>...</AreaId>

public string Id

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

public Area[] Areas

[XmlElementAttribute("Area", IsNullable = false)]    // 表现为水平结构的Xml节点。<Area ... /><Area ... />...

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;

3. /// <summary>

4. /// 班级信息类

5. /// </summary>

6. [XmlRootAttribute("MyClassInfo", Namespace = "ABC_123", IsNullable = false)]

7. public class ClassInfo

8. {

9. /// <summary>

10. /// 班级ID

11. /// </summary>

12. [XmlAttribute("MyClassID")]

13. public int ClassID { get; set; }

14. /// <summary>

15. /// 班级名称

16. /// </summary>

17. [XmlElementAttribute("MyClassName", IsNullable = false)]

18. public string ClassName { get; set; }

19. /// <summary>

20. /// 班长人

21. /// </summary>

22. [XmlElementAttribute("MyTeacher", IsNullable = false)]

23. public string Teacher { get; set; }

24. /// <summary>

25. /// 学生列表

26. /// </summary>

27. [XmlArrayAttribute("MyStudents")]

28. public List<Student> StudentList { get; set; }

29. }

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

1. using System.Xml.Serialization;

2. /// <summary>

3. /// 学生信息类

4. /// </summary>

5. [XmlRootAttribute("MyStudent", IsNullable = false)]

6. public class Student

7. {

8. /// <summary>

9. /// 学生ID

10. /// </summary>

11. [XmlAttribute("MyStuID")]

12. public int StuID { get; set; }

13. /// <summary>

14. /// 学生名称

15. /// </summary>

16. [XmlElementAttribute("MyStuName", IsNullable = false)]

17. public string StuName { get; set; }

18. /// <summary>

19. /// 性别

20. /// </summary>

21. [XmlElementAttribute("MySex", IsNullable = false)]

22. public string Sex { get; set; }

23. /// <summary>

24. /// 邮箱

25. /// </summary>

26. [XmlIgnoreAttribute]

27. public string Email { get; set; }

28. }

2.3 将班级信息转换成XML

1. /// <summary>

2. /// 将班级信息转换成XML

3. /// </summary>

4. public static void ClassInfoToXml()

5. {

6. //获取班级信息

7. ClassInfo classInfo = GetClassInfo();

8. //将班级信息转换成XML

9. string classXml = XmlSerializeHelper.XmlSerialize(classInfo);

10. }

11. /// <summary>

12. /// 获取班级信息

13. /// </summary>

14. public static ClassInfo GetClassInfo()

15. {

16. //创建班级信息

17. ClassInfo classInfo = new ClassInfo();

18. classInfo.ClassID = 1;

19. classInfo.ClassName = "高一（5）班";

20. classInfo.Teacher = "李老师";

21. //创建学生列表

22. List<Student> studentList = new List<Student>();

23. studentList.Add(new Student() { StuID = 1, StuName = "张三", Sex = "男", Email = "[email protected]" });

24. studentList.Add(new Student() { StuID = 2, StuName = "李四", Sex = "女", Email = "[email protected]" });

25. studentList.Add(new Student() { StuID = 3, StuName = "王五", Sex = "男", Email = "[email protected]" });

26. classInfo.StudentList = studentList;

27. return classInfo;

28. }

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>