前言：写此文章一方面是为了巩固对序列化的认识，另一方面是因为本人最近在面试，面试中被问到“为什么要序列化”。虽然一直在使用，自己也反复的提到序列化，可至于说为什么要序列化，还真的没想过，所以本文就这样产生了。
序列化是将一个对象转换成一个字节流的过程。反序列化是将一个字节流转换回对象的过程。在对象和字节流之间转换是很有用的一个机制。(当然这个还不能回答它的实际用处)
举点例子：
- 应用程序的状态可以保存到一个磁盘文件或数据库中，并在应用程序下次运行时恢复。比如ASP.NET就是利用系列化和反序列化保存和恢复回话状态。
- 一组对象可以轻松复制到系统的剪切板，然后再粘贴到其他的地方(应用程序)。
- 一组对象可克隆并放到其他地方作为备份。
- 一组对象可以通过网络发送给另一台机器上运行的进程(比如Remoting)。
除了上述的几个场景，我们可以将系列化得到的字节流进行任意的操作。
一、序列化、反序列化快速实践
[Serializable] class MyClass { public string Name { get; set; } }
一个自定义类，切记需要加上[Serializable]特性(可应用于class、struct、enum、delegate)。
private static MemoryStream SerializeToMemoryStream(object objectGraph) { //一个流用来存放序列化对象 var stream = new MemoryStream(); //一个序列化格式化器 var formater = new BinaryFormatter(); //将对象序列化到Stream中 formater.Serialize(stream, objectGraph); return stream; } private static object DeserializeFromMemory(Stream stream) { var formater = new BinaryFormatter(); return formater.Deserialize(stream); }
SerializeToMemoryStream为序列化方法，此处通过BinaryFormatter类将对象序列化到MemoryStream中，然后返回Stream对象。
DeserizlizeFromMemory为反序列化方法，通过传入的Stream，然后使用BinaryFormatter的Deserialize方法反序列化对象。
除了可以使用BinaryFormatter进行字节流的序列化，还可以使用XmlSerializer(将对象序列为XML)和DataContratSerializer。
Serialize的第二个参数是一个对象的引用，理论上应该可以是任何类型，不管.net的基本类型还是其他类型或者是我们的自定义类型。如果是对象和对象的引用关系，Serizlize也是可以一直序列化的，而且Serialize会很智能的序列化每个对象都只序列化一次，防止进入无限循环。
P.S. 1.Serialze方法其实可以将对象序列化为Stream，也就意味着不仅可以序列化为MemoryStream，还可以序列化为FIleStream或者是其他继承自Stream的类型。
2.除了上述的将一个对象序列化到一个Stream，也可以将多个对象序列化中，还是调用Serialize方法，第二个参数为不同的对象即可；在反序列化的时候同样的方法，只不过 强转的类型指定为需要的即可。
序列化多个对象到Stream:
MyClass class1 = new MyClass(); MyClass2 class2=new MyClass2(); formater.Serialize(stream,class1); formater.Serialize(stream,class2);
从Stream中反序列化多个对象：
MyClass class1 =(MyClass) formater.Deserialize(stream);
MyClass1 class2 = (MyClass1)formater.Deserialize(stream);
二、控制序列化和反序列化
如果给类添加了SerializeAttribute，那么类的所有实例字段(private、protected、public等)都会被序列化。但是，有时候类型中定义了一些不应序列化的实例字段。
一般情况下，以下两种情况不希望序列化字段：
- 字段含有反序列化后变得无效的信息。例如，假定一个对象包含到一个Windows内核对象(如文件、进程、线程、事件等)，那么在反序列化到另一个进程或另一台机器之后，就会失去意义。
- 字段含有很容易计算的信息。在这种情况下，要选出那些无需序列化的字段，减少需要传输的数据，从而增强应用程序的性能。
使用NonSerializedAttribute特性来指明哪些字段无需序列化。
[NonSerialized] private string _name;
p.s.[NoSerialized] 仅仅能添加在字段，或者是没有get和set访问器属性上，对于有get和set这样的属性使用是不行的。没关系使用[ScriptIgnore]特性标识属性则可以忽略JSON这样的序列化、使用[XmlIgnoreAttribute]特性标识属性则可以忽略XmlSerializer的序列化操作。
虽然使用NonSerizlized特性可以使字段不被序列化，但是在序列化或者反序列化的时候往往都会把值清空，或者是没有一些希望的默认值，还好我们可以使用其他的特性来辅助完成。
修改下上文中的MyClass：
[Serializable] class MyClass { [NonSerialized] public string _name; [OnDeserialized] private void OnDeserialized(StreamingContext context) { _name = "Mario"; } [OnDeserializing] private void OnDeserializing(StreamingContext context) { _name = "super"; } [OnSerializing] private void OnSerializing(StreamingContext context) { _name = "listen"; } [OnSerialized] private void OnSerialized(StreamingContext context) { _name = "fly"; } public void Print() { Console.WriteLine(_name); } }
在类中一共使用了四个特性，OnDeserialized、OnDeserializing、OnSerializing、OnSerialized，分别是反序列化后、反序列化前、序列化前、序列化后。不过，如果同时指定了OnDeserialized和OnDeserializing，那么结果应该是OnDeserialized中的逻辑；同理，如果同时指定了OnSerializing和OnSerialized，那么结果应该是OnSerialized中的逻辑。另外，在一个类中，仅仅能指定一个方法为上述中的一个特性(即OnSerialized特性只能被一个方法使用、OnSerialized特性只能被一个方法使用，其余两个同理)，否则序列化或者反序列化则会出现异常。
P.S. 这些方法通常为private的，并且参数为StreamingContext。
MyClass class1 = new MyClass(); var stream = SerializeToMemoryStream(class1); class1.Print(); stream.Position = 0; class1 = (MyClass)DesrializeFromMemory(stream); class1.Print(); Console.Read();
运行上述调用可以发现，虽然我们没有将name属性序列化，但是在序列化/反序列化之后还是可以输出值的，如果你同时指定了OnDeserializing和OnDeserialized或者同时指定了OnSerializing和OnSerialized，那么你会发现使用的都是后者的值，这也验证了上述中的解释。
有时候我们的类可能会增加字段，可是呢，我们已经序列化好的数据是旧的版本，所以在反序列化的时候就会出现异常，还好我们也有办法，给新加的字段都增加一个OptinalFieldAttribute特性，这样当格式化器看到该attribute应用于一个字段时，就不会因为流中的数据不包含这个字段而出现异常。
三、序列化和反序列化的原理
为了简化格式化器的操作，在System.Runteime.Serialization中有一个FormatterServices类型。该类型只包含静态方法，并且该类为静态类。
Serialize步骤：
- 格式化器调用FormatterServices的GetSerializableMembers方法：
public static MemberInfo[] GetSerializableMembers(Type type,StreamContext context);
这个方法利用反射获取类型的public和private实例字段(除了标识为NonSerializedAttribute的字段除外)。方法返回由MemberInfo对象构成的一个数组，其中每个元素都对应于一个可序列化的实例字段。
- 对象被序列化，MemberInfo对象数组传给FormatterServices的静态方法GetObjectData:
public static object[] GetObjectData(Object obj,MemberInfo[] members);
这个方法返回一个Object数组，其中每个元素都标识了被序列化的那个对象的一个字段的值。这个Object数组和MemberInfo数组是并行的；也就是说，Object数组中的元素0是MemberInfo数组中的元素0所标识的那个成员的值。
- 格式化器将程序集标识和类型的完整名称写入流中。
- 格式化器然后遍历两个数组中的元素，将每个成员的名称和值写入流中。
Deserialize步骤：
- 格式化器从流中读取程序集标识和完整类型名称。如果程序集当前没有加载到AppDomain中，就加载它。如果程序集不能加载，则出现异常。如果程序集已经加载，格式化器将程序集标识信息和类型全名传给FormatterServices的静态方法GetTypeFromAssembly：
public static Type GetTypeFromAssembly(Assembly assembly, string name);
这个方法返回一个Type对象，代表要反序列化的那个对象的类型。
- 格式化器调用FormatterServices的静态方法GetUninitializedObject:
public static Object GetUninitializedObject(Type type);
这个方法为一个新对象分配内存，并不为对象调用构造函数。所以，对象的所有字段都被初始化为null或者0;
- 格式化器现在构造并初始化一个MemberInfo数组，同样是调用FormatterServices的GetSerializableMembers方法。这个方法返回序列化好，需要反序列化的一组字段。
- 格式化器根据流中包含的数据创建并初始化一个Object数组。
- 将对新分配的对象、MemberInfo数组以及并行Object数组的传给FomatterServices的静态方法PopulateObjectMembers:
public static Object PopulateObjectMembers(Object obj,MemberInfo[] members, Object [] data);
这个方法遍历数组，将每个字段初始化成对应的值。到这里，就算反序列化结束了。
四、控制序列化/反序列化的数据
本文上述，有提到如何使用OnSerializing、OnSerialized、OnDeserializing、OnDeserialized以及NonSerialized和OptionalField特性进行控制序列化和反序列化。但是，格式化器内部使用反射，而反射的速度是比较慢的，所以增加了序列化和反序列化对象所花的时间。为了对序列化和反序列化完全的控制，并且不使用反射，那么我们的类型可以实现ISerializable接口，此接口仅仅有一个方法：
public Interface ISerializable { void GetObjectData(SerializationInfo info, StreamContext context); }
一旦类型实现了此接口，所有派生类型也必须实现它，而且派生类型必须保证调用基类的GetOBjectData方法和特殊的构造器。除此之外，一旦类型实现了该接口，则永远不能删除它，否则会失去与派生类的兼容性。
ISerializable接口和特殊构造器旨在由格式化器使用。但是，任何代码都可能调用GetObjectData，则可能返回敏感数据。另外，其他代码可能构造一个对象，并传入损坏的数据。因此，建议将如下的attribute应用于GetObjectData方法和特殊构造器：
[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter = true)]
格式化器序列化一个对象时，会检查每个对象。如果发现一个对象的类型实现了ISerializable接口，格式化器就会忽略所有定制attribute，改为构造一个新的SerializationInfo对象，这个对象包含了要实际为对象序列化的值的集合。
构造一个SerializationInfo时，格式化器要两个参数：Type和IFormatterConverter。Type参数标识要序列化的对象。为了唯一性地标识一个类型，需要两个部分的信息：类型的字符串名称及其程序集的标识。一个SerializationInfo对象构造好之后，会包含类型的全名(即Type的FullName)，并将这个字符串存储到一个私有字段中。为了获取类型的全名，可使用SerializationInfo的FullTypeName属性。通过调用SerializationInfo的SetType方法，传递目标Type对象的引用，用于设置FullTypeName和AssemblyName属性。
构造好并初始化SerializationInfo对象后，格式化器调用类型的GetObjectData方法，传递SeriializationInfo对象。GetObjectData方法负责决定需要序列化的信息，然后将这些信息添加到SerializationInfo中。GetObjectData调用SerializationInfo类型的AddValue方法来指定要序列化的信息。需要对每个要添加的数据，都进行AddValue方法的调用。
下面代码展示了Dictionary<TKey,TValue>类型如何实现ISerializable和IDeserializationCallback接口来控制其对象的序列化和反序列化工作。
四、在基类没有实现ISerializable的情况下定义一个实现它的类型
之前提到，如果基类实现了ISerializable接口，那么它的派生类也必须实现ISerializable接口，同时还要调用基类的GetObjectData方法和特殊构造器。(见上文红色字体)
但是，你可能要定义一个类型来控制它的序列化，但它的基类没有实现ISerializable接口。在这种情况下，派生类必须手动序列化基类的字段，具体的做法是获取它们的值，并把这些值添加到SerializationInfo集合中。然后，在特殊构造器中，还必须从集合中取出值，并以某种方式设置基类的字段。如果基类的字段是public或者protected字段，还容易实现。但，如果基类的private字段，那么则很难实现。
以下代码实现如何正确实现ISerializable的GetObjectData方法和特殊的构造器：
[Serializable] class Base { protected string name = "Mario"; public Base() { } } [Serializable] class Derived : Base, ISerializable { private DateTime _date = DateTime.Now; public Derived() { }
//如果这个构造器不存在，则会引发一个SerializationException异常
//如果此类不是密封类，这个构造器就应该是protected的 [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)] private Derived(SerializationInfo info, StreamingContext context) { Type baseType = this.GetType().BaseType; MemberInfo[] memberInfos = FormatterServices.GetSerializableMembers(baseType, context); for (int i = 0; i < memberInfos.Length; i++) { FieldInfo fieldInfo = (FieldInfo)memberInfos[i]; fieldInfo.SetValue(this, info.GetValue(baseType.FullName + "+" + fieldInfo.Name, fieldInfo.FieldType)); } _date = info.GetDateTime("Date"); } [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)] public virtual void GetObjectData(SerializationInfo info, StreamingContext context) { info.AddValue("Data", _date); Type baseType = this.GetType().BaseType; MemberInfo[] memberInfos = FormatterServices.GetSerializableMembers(baseType,context); for (int i = 0; i < memberInfos.Length; i++) { info.AddValue(baseType.FullName + "+" + memberInfos[i].Name, ((FieldInfo)memberInfos[i]).GetValue(this)); } } public override string ToString() { return string.Format("Name={0},Date={}", name, _date); } }
在代码中，有一个名为Base的基类，它只用Serializable特性标识。其派生类Derived类，也使用了Serializable特性，同时还实现了ISerializable接口。同时两个类还定义了自己的字段，调用SerializationInfo的AddValue方法进行序列化和反序列化。
解释：
序列化： 每个AddValue方法都获取一个String名称和一些数据。数据一般是简单的类型，当然我们也可以传递object引用。GetObjectData添加好所有必要的序列化信息之后，会返回至格式化器。现在，格式化器获取已经添加到SerializationInfo对象的所有值，并把它们都序列化到流中。同时，我们还向GetObjectData方法中传递了另外一个参数StreamingContext对象的实例。当然，大多数类型的GetObjectData方法都忽略了此参数，下文详细说明。
反序列化：格式化器从流中提取一个对象时，会为新对象分配内存(通过FormatterService.GetUninitializedObject方法)。最初，此对象的所有字段都为0或者是null。然后，格式化器检查类型是否实现了ISerializable接口。如果存在此接口，格式化器则会尝试调用我们定义的特殊构造函数，它的参数和GetObjectData是一致的。
如果类是密封类，则建议将此特殊构造声明为private，这样就可以防止其他代码调用它。如果不是密封类，则应该将这个特殊构造器声明为protected，保证派生类可以调用它。切记，无论这个特殊构造器是如何声明的，格式化器都可以调用它的。
构造器获取对一个SerializationInfo对象的引用，在这个SerializationInfo对象中，包含了对象(要序列化的对象)序列化时添加的所有值。特殊构造器可调用GetBoolean,GetChar,GetByte,GetInt32和GetValue等任何一个方法，向他传递与序列化一个值所用的名称对应的一个字符串。以上的每个方法返回的值再用于初始化新对象的各个字段。
反序列化一个对象的字段时，应调用和对象序列化时传给AddValue方法的值得类型匹配的一个Get方法。也就是说，如果GetObjectData方法调用AddValue时传递的是一个Int32值，那么在反序列化对象的时候，也应该为同一个值调用GetInt32方法。如果值在流中的类型和你要获取的类型不匹配，格式化器则会尝试用IFormatterConverter对象将流中的值转换为你指定的类型。
上文中提到，构造SerializationInfo对象时，需要传递Type和IFormatterConverter接口的对象(此时，它是重点，不要被Type勾引走)。由于格式化器负责构造SerializationInfo对象，所以要由它选择它需要的IFormatterConverter。.Net的BinaryFormatter和SoapFormatter构造的就是一个FormatterConverter类型，.Net的格式化器没有提供一个让你可以选择的IFormatterConverter的实现。
FormatterConverter类型调用System.Convert类的各种静态方法在不同的类型之间进行转换，比如讲一个Int16转换为Int32。然而，为了在其他任意类型之间转换一个值，FormatterConverter需要调用Convert的ChangeType方法将序列化好的类型转换为一个IConvertible接口，然后再调用恰当的接口的方法。所以，要允许一个可序列化类型的对象反序列化成一个不同的类型，可以考虑让自己的类型实现IConvertible接口。切记，只有在反序列化对象时调用Get方法，并且发现了类型和流中的值得类型不匹配时候，才会使用FormatterConverter对象。
特殊构造器也可以不调用上面的各种Get方法，而是调用GetEnumerator。此方法会返回一个SerializationInfoEnumerator对象，可使用该对象遍历SerializationInfo对象中包含的所有的值。枚举的每个值都是一个SerializationEntry对象。
当然，我们完全可以自定义一个类型，让它实现ISerializable的GetObjectData方法和特殊构造器一个类型派生。如果我们的类型实现了ISerializable，那么可以在我们实现的GetObjectData方法和特殊构造器中，必须调用基类中的同名方法，以确保对象正确序列化和反序列化。这一点是必须的哦，否则对象时不能正确序列化和反序列化。
如果我们的派生类型中没有其他的额外字段，当然也没有特殊的序列化和反序列化需求，就不用事先ISerializable接口。和其他接口成员相似，GetObjectData是virtual的，调用它可以正确的序列化对象。格式化器将特殊构造器视为“已虚拟化”，也就是说，反序列化过程中，格式化器会检查要实例的类型，如果那个类型没有提供特殊的特殊构造器，则会看其基类是否存在，知道找到一个实现了特殊构造器的一个类。
注意：特殊构造器中的代码一般会从传给 它的SerializationInfo对象中提取字段。提取了字段后，不能保证对象已完全反序列化，所以特殊构造器中的代码不应尝试操纵它提取的对象。如果我们的类型必须访问提取的一个对象中的成员，最好我们的类型提供一个应用了OnDeserialized特性的方法，或者让我们的类型实现IDeserializationCallback接口的OnDeserialization方法。调用该方法时，所有对象的字段都已经设置好。然而，对于多个对象来说，它们的OnDeserialized或OnDeserialization方法的调用顺序是没有保障的。所以，虽然字段可能已经初始化，但我们仍然不知道被引用的对象是否已完全反序列化好(如果那个被引用的对象也提供了一个OnDeserialized方法或者实现了IDeserializationCallback)。
P.S. 必须调用AddValue方法的某个重载版本为自己的类型添加序列化信息。如果一个字段的类型实现了ISerializable接口，就不要在字段上调用GetObjectData，而应该调用AddValue来添加字段。格式化器会发现字段的类型实现了ISerializable，会自动调用GetObjectData。如果自己在字段上调用了GetObjectData，格式化器则不会知道在对流进行反序列化时创建一个新对象。
五、将类型序列化为不同的类型以及将对象反序列化为不同的对象
[Serializable] public class Student : ISerializable { private string _name; public string Name { get { return _name; } set { _name = value; } } [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)] public void GetObjectData(SerializationInfo info, StreamingContext context) { info.SetType(typeof(SerializationHelper)); } } [Serializable] public class SerializationHelper : IObjectReference { public object GetRealObject(StreamingContext context) { return "新的类型哦"; } }
上述代码中一个我们的数据类Student，还有一个序列化帮助类，其中Student类就是我们要序列化的类，帮助类就是为了告诉代码我们要把Student类序列化为它，并且再反序列化的时候也应该是它。
测试下：
static void Main(string[] args) { Student student = new Student { Name = "马里奥" }; using (var stream = new MemoryStream()) { BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, student); stream.Position = 0; var deserializeValue = formatter.Deserialize(stream); Console.Write(deserializeValue.ToString()); Console.Read(); } }
可以看到结果：
P.S. ISerializable:允许对象控制其自己的序列化和反序列化过程。
IObjectReference:指示当前接口实施者是对另一个对象的引用。
好了，序列化和反序列化的东西说的也差不多了，大家有什么更好的想法可以和我交流。