C# 二进制BinaryFormatter和Xml进行序列化与反序列化

序列化又称串行化，是.NET运行时环境用来支持用户定义类型的流化的机制。其目的是以某种存储形成使自定义对象持久化，或者将这种对象从一个地方传输到另一个地方。

.NET框架提供了两种种串行化的方式：1、是使用BinaryFormatter进行串行化；2、使用XmlSerializer进行串行化。第一种方式提供了一个简单的二进制数据流以及某些附加的类型信息，而第二种将数据流格式化为XML存储。    可以使用[Serializable]属性将类标志为可序列化的。如果某个类的元素不想被序列化，1、可以使用[NonSerialized]属性来标志，2、可以使用[XmlIgnore]来标志。

序列化意思指的是把对象的当前状态进行持久化，一个对象的状态在面向对象的程序中是由属性表示的，所以序列化类的时候是从属性读取值以某种格式保存下来，而类的成员函数不会被序列化，.net存在几种默认提供的序列化，二进制序列化，xml和json序列化会序列化所有的实例共有属性。

1. using UnityEngine;
2. using System;
3. using System.Collections;
4. using System.IO;
5. using System.Collections.Generic;
6. using System.Runtime.Serialization.Formatters.Binary;
8. [ Serializable] // 表示该类可以被序列化
9. class Person
10. {
11. private string name;
12. [ NonSerialized] // 表示下面这个age字段不进行序列化
13. private int age;
14. public string Name
15. {
16. get { return name;}
17. set { name = value;}
18. }
19. public int Age
20. {
21. get { return age;}
22. set { age = value;}
23. }
24. public Person() { }
25. public Person(string name, int age)
26. {
27. this.name = name;
28. this.age = age;
29. }
31. public void SayHi()
32. {
33. Debug.LogFormat ( "我是{0}, 今年{1}岁", name, age);
34. }
35. }
38. public class BinarySerializer : MonoBehaviour {
40. string filePath = Directory.GetCurrentDirectory() + "/binaryFile.txt";
42. // Use this for initialization
43. void Start () {
44. List<Person> listPers = new List<Person> ();
45. Person per1 = new Person ( "张三", 18);
46. Person per2 = new Person ( "李四", 20);
47. listPers.Add (per1);
48. listPers.Add (per2);
49. SerializeMethod (listPers); // 序列化
50. DeserializeMethod(); // 反序列化
51. Debug.Log( "Done ! ");
52. }
54. void DeserializeMethod() // 二进制反序列化
55. {
56. FileStream fs = new FileStream (filePath, FileMode.Open);
57. BinaryFormatter bf = new BinaryFormatter ();
58. List<Person> list = bf.Deserialize (fs) as List<Person>;
60. if (list != null)
61. {
62. for ( int i = 0; i < list.Count; i++)
63. {
64. list [i].SayHi ();
65. }
66. }
67. fs.Close ();
68. }
70. void SerializeMethod(List<Person> listPers) // 二进制序列化
71. {
72. FileStream fs = new FileStream (filePath, FileMode.Create);
73. BinaryFormatter bf = new BinaryFormatter ();
74. bf.Serialize (fs, listPers);
75. fs.Close ();
76. }
78. // Update is called once per frame
79. void Update () {
81. }
82. }

序列化的文本打开后，内容如下所示：

反序列化输出结果：

大家好，我是张三，今年0岁

大家好，我是李四，今年0岁

由此看出，未序列化的字段存储的值为空

使用XmlSerializer进行串行化
    关于格式化器还有一个问题，假设我们需要XML，有两中方案：要么编写一个实现IFormatter接口的类，采用的方式类似于SoapFormatter类,但是没有你不需要的信息；要么使用库类XmlSerializer，这个类不使用Serializable属性，但是它提供了类似的功能。
    如果我们不想使用主流的串行化机制，而想使用XmlSeralizer进行串行化我们需要做一下修改：
    a.添加System.Xml.Serialization命名空间。
    b.Serializable和NoSerialized属性将被忽略,而是使用XmlIgnore属性，它的行为与NoSerialized类似。
    c.XmlSeralizer要求类有个默认的构造器，这个条件可能已经满足了。
序列化：

XmlSerializer xs = new XmlSerializer(typeof(List<Peoson>));
xs.Serialize(fs, listPers);
反序列化：

XmlSerializer xs = new XmlSerializer(typeof(List<Peoson>));
List<Peoson> list = xs.Deserialize(fs) as List<Peoson>;

1. using UnityEngine;
2. using System;
3. using System.Collections;
4. using System.IO;
5. using System.Xml.Serialization;
6. using System.Xml;
7. using System.Collections.Generic;
9. [ Serializable] // 表示该类可以被序列化
10. [ XmlRoot("AAA")] // 设置为XML中的根元素名称
11. public class Person
12. {
13. private string name;
14. private int age;
16. // [XmlElement("abc")]
17. public int abc = 1000; // 类的public属性字段都可以被序列化
19. // [XmlAttribute("Name")] 设置作为xml中的属性
20. public string Name
21. {
22. get { return name;}
23. set { name = value;}
24. }
25. // [XmlElement("Age")] 设置作为XML中的元素（默认状态）
26. public int Age
27. {
28. get { return age;}
29. set { age = value;}
30. }
31. public Person() { }
32. public Person(string name, int age)
33. {
34. this.name = name;
35. this.age = age;
36. }
38. public void SayHi()
39. {
40. Debug.LogFormat ( "我是{0}, 今年{1}岁", name, age);
41. }
42. }
45. public class XmlSerialize : MonoBehaviour {
47. string filePath = Directory.GetCurrentDirectory() + "/XmlFile.txt";
48. string filePath2 = Directory.GetCurrentDirectory() + "/XmlClassFile.txt";
50. // Use this for initialization
51. void Start () {
52. List<Person> listPers = new List<Person> ();
53. Person per1 = new Person ( "张三", 18);
54. Person per2 = new Person ( "李四", 20);
55. listPers.Add (per1);
56. listPers.Add (per2);
57. SerializeMethod (listPers); // 序列化
58. DeserializeMethod(); // 反序列化
60. // SerializeClassMethod (per1);
61. // DeserializeClassMethod ();
62. Debug.Log( "Done ! ");
63. }
65. void DeserializeClassMethod() // Xml实体类反序列化
66. {
67. FileStream fs = new FileStream (filePath, FileMode.Open);
68. XmlSerializer xs = new XmlSerializer( typeof(Person));
69. Person p = xs.Deserialize (fs) as Person;
70. if (p != null)
71. {
72. p.SayHi ();
73. }
74. fs.Close ();
75. }
78. void SerializeClassMethod(Person p) // Xml实体类序列化
79. {
80. FileStream fs = new FileStream (filePath2, FileMode.Create);
81. XmlSerializer xs = new XmlSerializer( typeof(Person));
82. xs.Serialize(fs, p);
83. fs.Close ();
84. }
87. void DeserializeMethod() // Xml列表反序列化
88. {
89. FileStream fs = new FileStream (filePath, FileMode.Open);
90. XmlSerializer xs = new XmlSerializer( typeof(List<Person>));
91. List<Person> listPers = xs.Deserialize (fs) as List<Person>;
92. if (listPers != null)
93. {
94. for ( int i = 0; i < listPers.Count; i++)
95. {
96. listPers [i].SayHi ();
97. }
98. }
99. fs.Close ();
100. }
102. void SerializeMethod(List<Person> listPers) // Xml列表序列化
103. {
104. FileStream fs = new FileStream (filePath, FileMode.Create);
105. XmlSerializer xs = new XmlSerializer( typeof(List<Person>));
106. xs.Serialize(fs, listPers);
107. fs.Close ();
108. }
110. // Update is called once per frame
111. void Update () {
113. }
114. }

Xml列表序列化的内容：

Xml实体类序列化的内容：