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實體類序列化的內容：