深入解析：Unity：XML笔记(二)——Xml序列化、反序列化、IXmlSerializable接口

写在前面：

写本系列(自用)的目的是回顾已经学过的知识、记录新学习的知识或是记录心得理解，方便自己以后快速复习，减少遗忘。

三、Xml序列化

序列化就是把想要存储的内容转换为字节序列用于存储或传递。

1、序列化

我们先创建一个类，之后利用Xml序列化来存储这个类：

public class Test
{
public int testPublic = 10;
private int testPrivate = 11;
protected int testProtected = 12;
internal int testInternal = 13;
public string testPublicStr = "123";
public int testPro { get; set; }
public Test2 testClass = new Test2();
public int[] arrayInt = new int[3] { 5, 6, 7 };
public List listInt = new List() { 1, 2, 3, 4 };
public List listItem = new List() { new Test2(), new Test2() };
}
public class Test2
{
public int test1 = 1;
public float test2 = 1.1f;
public bool test3 = true;
}

Xml序列化的第一步是确认存储路径：string path = Application.persistentDataPath + "/Test.xml";该存储路径设置方式和之前使用XmlDocument存储的方式一样。

序列化存储需要在一个using代码块中，如下：

using (StreamWriter stream = new StreamWriter(path)){          }

现在对这行代码进行解释。StreamWriter是向文件流写入字符的类，属于System.IO命名空间。括号内的代码的意思是：写入一个文件流，如果有该文件，直接打开并修改；如果没有该文件，自动释放掉。new StreamWriter()
这里还涉及到using 的新用法：括号内包裹的声明的对象，会在大括号语句块结束后自动释放掉。当语句块结束时会自动调用对象的Dispose方法，让其销毁。using一般是配合 内存占用比较大或者有读写操作时进行使用。

在语句块中，我们需要创建一个“序列化机器”来将我们的类序列化：

 XmlSerializer s = new XmlSerializer(typeof(Test));

需要注意的是，序列化机器的类型，一定是要和我们需要序列化存储的对象是同样的类型。接下来就可以使用序列化机器进行序列化：

s.Serialize(stream, lt);

这句代码通过序列化机器，对我们类对象进行翻译，将其翻译成xml文件写入到对应文件中。第一个参数：文件流对象；第二个参数：想要被翻译的对象。这样，就完成了序列化存储：

public class lession1 : MonoBehaviour
{
void Start()
{
Test lt = new Test();
string path = Application.persistentDataPath + "/Test.xml";
using (StreamWriter stream = new StreamWriter(path))
{
XmlSerializer s = new XmlSerializer(typeof(Test));
s.Serialize(stream, lt);
}
}
}

我们可以在我们设置的保存路径中，找到序列化后的Xml文件：

10
123
1
1.1
true
5
6
7
1
2
3
4
1
1.1
true
1
1.1
true
0

可以看到，我们类中private、protected、internal修饰的变量都没有被序列化。也就是说，Xml序列化方法只能序列化公共成员。此外，不支持字典序列化，如果类中有字典，就会报错。

2、修改节点信息或设置属性信息

可以通过特性修改节点信息或者设置属性信息。例如，如果需要将Test2类中的成员以属性方式存储，可以加上特性：[XmlAttribute()]，如果想修改属性的名字，可以在括号内传入想要的属性名：[XmlAttribute("Test1")。

public class Test2
{
[XmlAttribute("Test1")]
public int test1 = 1;
[XmlAttribute()]
public float test2 = 1.1f;
[XmlAttribute()]
public bool test3 = true;
}

如果想要修改变量的名字，可以加上特性：[XmlElement("testPublic111")]，括号内传入属性名：

[XmlElement("testPublic111")]
public int testPublic = 10;

如果想要修改数组的名字，可以添加特性：[XmlArray("IntList")]，如果想要修改数组中元素节点的名字，可以用特性：[XmlArrayItem("Int32")]

[XmlArray("IntList")]
[XmlArrayItem("Int32")]
public int[] arrayInt = new int[3] { 5, 6, 7 };

四、Xml反序列化

反序列化就是把存储或收到的字节序列信息解析读取出来使用。

1、判断文件是否存在

在反序列化之前，需要判断文件是否存在。判断方式是：File.Exists(path)，括号中传入的是文件地址。

void Start()
{
string path = Application.persistentDataPath + "/Test.xml";
if(File.Exists(path))
{
}
}

2、反序列化

反序列化和序列化基本相同，区别就是这里使用的是StreamReader，从流中读出字符的类。如下：using (StreamReader reader = new StreamReader(path)){  }

同样的，在using语句块中，初始化一个反序列化翻译机器： XmlSerializer s = new XmlSerializer(typeof(Test));

然后调用s.Deserialize(reader)方法即可完成反序列化：

void Start()
{
string path = Application.persistentDataPath + "/Test.xml";
if(File.Exists(path))
{
using (StreamReader reader = new StreamReader(path))
{
XmlSerializer s = new XmlSerializer(typeof(Test));
Test lt = s.Deserialize(reader) as Test;
}
}
}

这里需要注意的是，在三中定义Test类时，为了方便，很多值都是直接在类中初始化的。对于List对象，如果有默认值，反序列化时不会清空而是会往后继续添加，所以最好不要在类中直接初始化。

五、IXmlSerializable接口

C#的的XmlSerializer提供了可扩展内容，可以让一些不能被序列化和反序列化的特殊类能被处理，例如字典。让特殊类继承 IXmlSerializable接口实现其中的方法即可。

1、自定义序列化和反序列化

先按三、四所学知识创建一个类并书写序列化和反序列化方法：

public class Test3
{
public int test1;
public string test2;
}
public class lession3 : MonoBehaviour
{
void Start()
{
Test3 t = new Test3();
string path = Application.persistentDataPath + "/Test3.xml";
using (StreamWriter writer = new StreamWriter(path))
{
XmlSerializer s = new XmlSerializer(typeof(Test3));
s.Serialize(writer, t);
}
using(StreamReader reader = new StreamReader(path))
{
XmlSerializer s = new XmlSerializer(typeof(Test3));
Test3 t2 = s.Deserialize(reader) as Test3;
}
}
}

这段代码实现了对类Test3进行序列化和反序列化。这里补充一点，在序列化时 如果对象中的引用成员为空 那么xml里面是看不到该字段的，所以这里的xml文件中没有string。

接下来，我们就可以开始自定义序列化方法和反序列化方法。首先需要类Test3继承IXmlSerializable接口，并在Test3中重写接口中的函数：

其中public XmlSchema GetSchema()暂时不需要了解，该函数返回结构，直接return null即可。public void ReadXml(XmlReader reader)是反序列化会调用的方法，在其中书写的代码能够替换掉该类原来的反序列化函数。public void WriteXml(XmlWriter writer)是序列化会调用的方法。这两个函数可以定义序列化的规则。

public class Test3:IXmlSerializable
{
public int test1;
public string test2;
//返回结构
public XmlSchema GetSchema()
{
return null;
}
//反序列化时会自动调用方法
public void ReadXml(XmlReader reader)
{
}
//序列化时会自动调用的方法
public void WriteXml(XmlWriter writer)
{
}
}

(1)自定义读属性和写属性

首先来自定义读属性和写属性的规则。如果要自定义序列化的规则，一定会用到XmlWriter、XmlReader中的一些方法。

对于写属性，XmlWriter是写入器对象提供一系列方法来生成和写入 XML 格式的数据。可以使用：writer.WriteAttributeString()写入属性，括号内传入的第一个参数是属性名，第二个参数是属性的内容。

对于读属性，XmlReader则是用于读入数据的工具类。可以通过reader["test1"]来获得[]内属性的值。如下所示：

public void ReadXml(XmlReader reader)
{
this.test1 = int.Parse(reader["test1"]);
this.test2 = reader["test2"];
}
public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("test1", this.test1.ToString());
writer.WriteAttributeString("test2", this.test2)
}

(2)自定义读节点和写节点

①方式1

写节点可以通过XmlWriter的方法：writer.WriteElementString()，括号内分别传入节点名、节点的数值即可。

读节点需要用reader.Read()，表示逐步读。一开始Reader位于根节点Test3，调用reader.Read()后读到test1节点，继续调用reader.Read()后读到test1节点包裹的内容，此时就可以将该值读出来。继续调用reader.Read()后读到尾部包裹节点，再调用reader.Read()读到test2节点...以此类推。

  这里为了方便看所以给test2赋值为了123再进行读写数据。

public void ReadXml(XmlReader reader)
{
reader.Read();//这时是读到的test1节点
reader.Read();//这时是读到的test1节点包裹的内容
this.test1 = int.Parse(reader.Value);
reader.Read();//尾部包裹节点
reader.Read();//这时读到的是test2节点
reader.Read();//读到的是test2节点包裹的内容
this.test2 = reader.Value;
}
public void WriteXml(XmlWriter writer)
{
writer.WriteElementString("test1", this.test1.ToString());
writer.WriteElementString("test2", this.test2);
}

②方式2

方式①读节点的重复代码太多了，可以采用方式2这种写法：

while(reader.Read())
{
if(reader.NodeType == XmlNodeType.Element)
{
switch(reader.Name)
{
case "test1":
reader.Read();
this. test1 = int.Parse(reader.Value);
break;
case "tese2":
reader.Read();
this.test2 = reader.Value;
break;
}
}
}

(3)自定义读写包裹节点

如果想自定义写包裹节点，类似于下图，test1中包裹着节点int，test2中包裹着节点string

①写

以第一个写int为例。需要先声明一个序列化器

XmlSerializer s = new XmlSerializer(typeof(int));

然后使用节点相关API：这两句代码表示开始节点test1，结束节点test1，在这两行中间定义的节点就会被包裹在节点test1中间。

writer.WriteStartElement("test1");
writer.WriteEndElement();

例如，在以上两句代码中间使用序列化器写入节点teat的值，序列化器是int类型的，所以会生成<int>0</int>节点：

writer.WriteStartElement("test1");
s.Serialize(writer, test1);
writer.WriteEndElement();

②读

同样以读int为例，首先需要创建一个序列化器：

XmlSerializer s = new XmlSerializer(typeof(int));

调用reader.Read()让reader指向test1：

reader.Read();

然后可以使用以下两句代码，表示读test1节点的开始于结束：

reader.ReadStartElement("test1");
reader.ReadEndElement();

最后在中间写需要读入的数据即可：

reader.ReadStartElement("test1");
test1 = (int)s.Deserialize(reader);
reader.ReadEndElement();

完整代码：

public void ReadXml(XmlReader reader)
{
XmlSerializer s = new XmlSerializer(typeof(int));
reader.Read();
reader.ReadStartElement("test1");
test1 = (int)s.Deserialize(reader);
reader.ReadEndElement();
XmlSerializer s2 = new XmlSerializer(typeof(string));
reader.ReadStartElement("test2");
test2 = (string)s2.Deserialize(reader);
reader.ReadEndElement();
}
public void WriteXml(XmlWriter writer)
{
XmlSerializer s = new XmlSerializer(typeof(int));
writer.WriteStartElement("test1");
s.Serialize(writer, test1);
writer.WriteEndElement();
XmlSerializer s2 = new XmlSerializer(typeof(string));
writer.WriteStartElement("test2");
s2.Serialize(writer, test2);
writer.WriteEndElement();
}

2、让Dictionary支持序列化反序列化

相当于以上知识的一个小应用，可以拓展一个可以被序列化和反序列化的字典类，所以不多解释：

public class SerializerDictionary : Dictionary, IXmlSerializable
{
public XmlSchema GetSchema()
{
return null;
}
public void ReadXml(XmlReader reader)
{
XmlSerializer keySer = new XmlSerializer(typeof(TKey));
XmlSerializer ValueSer = new XmlSerializer(typeof(TValue));
reader.Read();
while(reader.NodeType != XmlNodeType.EndElement)
{
TKey key = (TKey)keySer.Deserialize(reader);
TValue value = (TValue)ValueSer.Deserialize(reader);
this.Add(key, value);
}
reader.Read();
}
public void WriteXml(XmlWriter writer)
{
XmlSerializer keySer = new XmlSerializer(typeof(TKey));
XmlSerializer ValueSer = new XmlSerializer(typeof(TValue));
foreach(KeyValuePair kv in this)
{
keySer.Serialize(writer, kv.Key);
ValueSer.Serialize(writer, kv.Value);
}
}
}