.NET陷阱之一：IDeserializationCallback带来的问题

代码中有一个类，其中包含一个字典（Dictionary<Key, Value>），本来想让前者实现IDeserializationCallback接口，以便在反序列化时根据字典的内容做一些初始化工作，结果循环字典元素的代码就是不走。费了好大劲才找到原因，先来看有问题的代码：

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace DotNetBugs
{
    [Serializable]
    public class Example : IDeserializationCallback
    {
        private Dictionary<string, string> map = new Dictionary<string, string>();

        public Example()
        {
            map.Add("one", "1");
            map.Add("two", "2");
        }

        public void OnDeserialization(object sender)
        {
            Dump();
        }

        public void Dump()
        {
            foreach (var item in map)
            {
                Console.WriteLine(item.Key + " -> " + item.Value);
            }
        }
    }

    public class Starter
    {
        public static void Main(string[] args)
        {
            using (var stream = new MemoryStream())
            {
                var formatter = new BinaryFormatter();
                formatter.Serialize(stream, new Example());

                stream.Seek(0, SeekOrigin.Begin);
                var example = (Example)formatter.Deserialize(stream);

                Console.WriteLine("after deserialize");
                example.Dump();

                Console.Read();
            }
        }
    }
}

你期望控制台有什么样的输出呢，是不是这样？

one -> 1               |
two -> 2               | 在第44行反序列化时，Example.OnDeserialization中调用Dump的输出。
after deserialize
one -> 1               |
two -> 2               | 在第47行调用Dump的输出

但实际的输出内容是：

after deserialize
one -> 1
two -> 2

为什么会这样呢？

来看一下Dictionary<Key, Value>的源代码（通过.NET Reflector反编译得到，代码已经简化，只显示与此问题相关的部分 ）：

[Serializable]
public class Dictionary<TKey, TValue> : ISerializable, IDeserializationCallback
{
    private SerializationInfo m_siInfo;
    
    protected Dictionary(SerializationInfo info, StreamingContext context)
    {
        this.m_siInfo = info;
    }
    
    public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("Version", this.version);
        info.AddValue("Comparer", this.comparer, typeof(IEqualityComparer<TKey>));
        info.AddValue("HashSize", (this.buckets == null) ? 0 : this.buckets.Length);
        if (this.buckets != null)
        {
            KeyValuePair<TKey, TValue>[] array = new KeyValuePair<TKey, TValue>[this.Count];
            this.CopyTo(array, 0);
            info.AddValue("KeyValuePairs", array, typeof(KeyValuePair<TKey, TValue>[]));
        }
    }

    public virtual void OnDeserialization(object sender)
    {
        if (this.m_siInfo != null)
        {
            int num = this.m_siInfo.GetInt32("Version");
            int num2 = this.m_siInfo.GetInt32("HashSize");
            this.comparer = (IEqualityComparer<TKey>)this.m_siInfo.GetValue(
                   "Comparer", typeof(IEqualityComparer<TKey>));
            if (num2 != 0)
            {
                this.buckets = new int[num2];
                for (int i = 0; i < this.buckets.Length; i++)
                {
                    this.buckets[i] = -1;
                }
                this.entries = new Entry<TKey, TValue>[num2];
                this.freeList = -1;
                KeyValuePair<TKey, TValue>[] pairArray = (KeyValuePair<TKey, TValue>[])
                       this.m_siInfo.GetValue("KeyValuePairs", 
                       typeof(KeyValuePair<TKey, TValue>[]));
                if (pairArray == null)
                {
                    ThrowHelper.ThrowSerializationException(
                           ExceptionResource.Serialization_MissingKeyValuePairs);
                }
                for (int j = 0; j < pairArray.Length; j++)
                {
                    if (pairArray[j].Key == null)
                    {
                        ThrowHelper.ThrowSerializationException(
                               ExceptionResource.Serialization_NullKey);
                    }
                    this.Insert(pairArray[j].Key, pairArray[j].Value, true);
                }
            }
            else
            {
                this.buckets = null;
            }
            this.version = num;
            this.m_siInfo = null;
        }
    }
}
 

原来Dictionary<Key, Value>在内部是通过数组的形式将自己的内容序列化到流中的，它也实现了IDeserializationCallback接口，用于在反序列化时重新构建字典。

问题就在这里——在Example类的对象被反序列化时，对象图中一共有两个实现IDeserializationCallback接口的对象，而且从结果来看，Example.map的OnDeserialization方法是在Example类对象之后被调用的，所以Example.OnDeserialization调用时map中还没有任何内容！

所以要解决这一问题，我们需要将代码改成下面那样：

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace dotNetBugs
{
    [Serializable]
    public class Example : ISerializable, IDeserializationCallback
    {
        [NonSerialized]
        private Dictionary<string, string> map = new Dictionary<string, string>();

        public Example()
        {
            map.Add("one", "1");
            map.Add("two", "2");
        }

        private Example(SerializationInfo info, StreamingContext context)
        {
            var keys = (string[])info.GetValue("MapKeys", typeof(object));
            var vals = (string[])info.GetValue("MapVals", typeof(object));
            map = new Dictionary<string, string>();
            for (int i = 0; i < keys.Length; ++i)
            {
                map.Add(keys[i], vals[i]);
            }
        }

        public void OnDeserialization(object sender)
        {
            Dump();
        }

        public void Dump()
        {
            foreach (var item in map)
            {
                Console.WriteLine(item.Key + " -> " + item.Value);
            }
        }

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            var keys = new string[map.Count];
            var vals = new string[map.Count];
            int i = 0;
            foreach (var item in map)
            {
                keys[i] = item.Key;
                vals[i] = item.Value;
                ++i;
            }

            info.AddValue("MapKeys", keys);
            info.AddValue("MapVals", vals);
        }
    }

    public class Starter
    {
        public static void Main(string[] args)
        {
            using (var stream = new MemoryStream())
            {
                var formatter = new BinaryFormatter();
                formatter.Serialize(stream, new Example());

                stream.Seek(0, SeekOrigin.Begin);
                var example = (Example)formatter.Deserialize(stream);

                Console.WriteLine("after deserialize");
                example.Dump();

                Console.Read();
            }
        }
    }
}

这样，输出就像预料的一样了。

总结一下：如果某个类Outer实现了IDeserializationCallback接口，而且OnDeserialization方法中的逻辑依赖于Outer类的某个成员inner，则一定检查inner是否也实现了IDeserializationCallback接口，如果是就需要特殊处理它的序列化过程。