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.  

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. }

33.  

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; }

10.  

11. /// <summary>

12. /// 名称

13. /// </summary>

14. public string Name { get; set; }

15.  

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

8.  

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

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

11.  

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

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

14. }

15.  

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

8.  

9. //将DataTable转换成XML

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

11.  

12. //将XML转换成DataTable

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

14. }

15.  

16. /// <summary>

17. /// 创建DataTable对象

18. /// </summary>

19. public static DataTable CreateDataTable()

20. {

21. //创建DataTable

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

23.  

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

28.  

29. //创建数据

30. DataRow dr = dt.NewRow();

31. dr["ID"] = 1;

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

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

34. dt.Rows.Add(dr);

35.  

36. dr = dt.NewRow();

37. dr["ID"] = 2;

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

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

40. dt.Rows.Add(dr);

41.  

42. dr = dt.NewRow();

43. dr["ID"] = 3;

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

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

46. dt.Rows.Add(dr);

47.  

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

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; }

15.  

16. /// <summary>

17. /// 班级名称

18. /// </summary>

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

20. public string ClassName { get; set; }

21.  

22. /// <summary>

23. /// 班长人

24. /// </summary>

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

26. public string Teacher { get; set; }

27.  

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;

2.  

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; }

14.  

15. /// <summary>

16. /// 学生名称

17. /// </summary>

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

19. public string StuName { get; set; }

20.  

21. /// <summary>

22. /// 性别

23. /// </summary>

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

25. public string Sex { get; set; }

26.  

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

8.  

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

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

11. }

12.  

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 = "李老师";

23.  

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;

30.  

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>