C# 串行化與反串行化--自定義序列化

5、自定義序列化
如果你希望讓用戶對類進行串行化，但是對數據流的組織方式不完全滿意，那麼可以通過在自定義類中實現接口來自定義串行化行爲。這個接口只有一個方法，GetObjectData．這個方法用於將對類對象進行串行化所需要的數據填進SerializationInfo對象。你使用的格式化器將構造SerializationInfo對象，然後在串行化時調用GetObjectData．如果類的父類也實現了ISerializable，那麼應該調用GetObjectData的父類實現。
 
　　如果你實現了ISerializable，那麼還必須提供一個具有特定原型的構造器，這個構造器的參數列表必須與GetObjectData相同。這個構造器應該被聲明爲私有的或受保護的，以防止粗心的開發人員直接使用它。

public enum SexType
    {
        Male,
        Female
    }
    [Serializable()]
    public class Item
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }

        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public Item() { } // 必須有默認構造函數，才能xml序列化
        public Item(int id, string name)
        {
            ID = id;
            Name = name;
        }

        public override string ToString()
        {
            return id.ToString() + "," + name;
        }

        public static Item ToObject(string str)
        {
            Item item = new Item();
            item.id = int.Parse(str.Split(',')[0]);
            item.name = str.Split(',')[1];
            return item;
        }
    }
    [Serializable()]
    public class ItemSub : Item
    {
        private SexType sex;
        public SexType Sex
        {
            get { return sex; }
            set { sex = value; }
        }

        public ItemSub() { } // 必須有默認構造函數，才能xml序列化
        public ItemSub(int id, string name, SexType sex)
            : base(id, name)
        {
            this.sex = sex;
        }
    }

    [Serializable()]
    public class ListBuffer : ISerializable
    {
        private List<string> list = new List<string>();

        public void Add(string str)
        {
            lock (list)
            {
                list.Add(str);
            }
        }

        public void Remove(string str)
        {
            lock (list)
            {
                list.Remove(str);
            }
        }

        public int Count
        {
            get { return list.Count; }
        }

        /// <summary>
        /// 自定義序列化方法
        /// 爲了讓子類能定義自定義序列化方法，這裏必須標記爲virtual
        /// 從接口中繼承而來的方法沒有任何修飾符，必須繼承後自己添加
        /// 如果這個方法不標記爲virtual，那麼子類將不能重寫自己的序列化方法
        /// </summary>
        /// <param name="info"></param>
        /// <param name="ctxt"></param>
        public virtual void GetObjectData(SerializationInfo info, StreamingContext ctxt)
        {
            int index = 0;
            foreach (string str in list)
            {
                // 由於是列表，所以不能給每個對象分配一個固定的鍵名，所以這裏用索引序號代替
                info.AddValue(index.ToString(), str);
                index++;
            }
        }

        public ListBuffer() { }
        protected ListBuffer(SerializationInfo info, StreamingContext ctxt)
        {
            int i = 0;
            SerializationInfoEnumerator irator = info.GetEnumerator();
            while (irator.MoveNext())
            {
                if (irator.Name.IndexOf("sub") == -1) // 這裏先要過濾掉子類中添加的鍵名，否則會異常
                {
                    // 反序列化，從流中找到可用的鍵
                    object o = info.GetValue(i.ToString(), typeof(string));
                    if (o != null)
                        list.Add(o.ToString());
                }

                i++;
            }
        }
    }
    [Serializable()]
    public class ListBufferSub : ListBuffer
    {
        private List<Item> listItem = new List<Item>();

        public void AddItem(Item item)
        {
            lock (listItem)
            {
                listItem.Add(item);
            }
        }

        public void Remove(Item item)
        {
        }

        /// <summary>
        /// 子類要增加自己的序列化對象，必須重載基類的GetObjectData
        /// 再次重申一遍，基類從接口繼承的GetObjectData默認不是virtual的，必須手動加上virtual修飾符
        /// </summary>
        /// <param name="info"></param>
        /// <param name="ctxt"></param>
        public override void GetObjectData(SerializationInfo info, StreamingContext ctxt)
        {
            base.GetObjectData(info, ctxt); // 先調用基類的自定義序列化方法

            int index = base.Count; // 索引序號從基類的索引序號開始
            foreach (Item item in listItem) // 然後再將子類自己的序列化成員添加到序列流中
            {
                info.AddValue("sub"+index.ToString(), item);
                index++;
            }
        }

        public ListBufferSub() { }
        protected ListBufferSub(SerializationInfo info, StreamingContext ctxt)
            : base(info, ctxt) // 先調用基類的反序列化構造方法（序列化流中包含基類和子類的鍵，在使用是要注意剔除）
        {
            int i = 0;
            SerializationInfoEnumerator irator = info.GetEnumerator();
            while (irator.MoveNext())
            {
                if (irator.Name.IndexOf("sub") != -1) // 找到子類的鍵
                {
                    object o = info.GetValue("sub" + i.ToString(), typeof(Item)); // 獲得子類的對象
                    if (o != null && o is Item)
                        listItem.Add(o as Item);
                }
                i++;
            }
        }
    }

    [Serializable()]
    public class BinarySerialize
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }

        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        private SexType sex;
        public SexType Sex
        {
            get { return sex; }
            set { sex = value; }
        }

        private List<string> listStr;
        public List<string> ListStr
        {
            get { return listStr; }
            set { listStr = value; }
        }

        private List<Item> listItem;
        public List<Item> ListItem
        {
            get { return listItem; }
            set { listItem = value; }
        }

        private ListBuffer buffer = new ListBuffer();
        public ListBuffer Buffer
        {
            get { return buffer; }
            set { buffer = value; }
        }

        private ListBufferSub bufferSub = new ListBufferSub();
        public ListBufferSub BufferSub
        {
            get { return bufferSub; }
            set { bufferSub = value; }
        }

        private List<ListBuffer> listBuffer;
        public List<ListBuffer> ListBuffer
        {
            get { return listBuffer; }
            set { listBuffer = value; }
        }
    }

    public sealed class ConfigurationManagerBinarySerialize
    {
        private static string path = System.Windows.Forms.Application.StartupPath + "\\BinarySerialize.bat";

        public static BinarySerialize Get()
        {
            if (!File.Exists(path))
                return null;

            BinaryFormatter b = new BinaryFormatter();
            using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
            {
                return (BinarySerialize)b.Deserialize(fs);
            }
        }

        public static void Set(BinarySerialize hr)
        {
            BinaryFormatter b = new BinaryFormatter();
            using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))
            {
                b.Serialize(fs, hr);
            }
        }
    }

備註：

這裏寫了一個很複雜的自定義序列化的例子，其中包含集合，繼承等關係。

對於需要自定義序列化的類，需要使其繼承ISerializable接口，實現GetObjectData函數以及添加一個帶相同參數的構造函數。

序列化時，系統調用GetObjectData保存信息，反序列化時，系統調用帶參數的構造函數創建對象。

如果基類自定義了序列化，那麼子類在自定義序列化方法時首先要調用基類的自定義方法，然後再進行自己的序列化操作。

基類的GetObjectData方法必須註明是virtual的，否則子類無法正常序列化。

自定義序列化必須使用BinaryFormatter進行序列化操作，xml無法正常工作。