C# 串行化与反串行化--自定义序列化_c# 自定义序列化 getobjectdata 兼容

作者：菜鸟追梦旅行 | 2024-02-19 01:36:15

踩

c# 自定义序列化 getobjectdata 兼容

5、自定义序列化
如果你希望让用户对类进行串行化，但是对数据流的组织方式不完全满意，那么可以通过在自定义类中实现接口来自定义串行化行为。这个接口只有一个方法，GetObjectData．这个方法用于将对类对象进行串行化所需要的数据填进SerializationInfo对象。你使用的格式化器将构造SerializationInfo对象，然后在串行化时调用GetObjectData．如果类的父类也实现了ISerializable，那么应该调用GetObjectData的父类实现。

　　如果你实现了ISerializable，那么还必须提供一个具有特定原型的构造器，这个构造器的参数列表必须与GetObjectData相同。这个构造器应该被声明为私有的或受保护的，以防止粗心的开发人员直接使用它。

[csharp]view plaincopy 
   
 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无法正常工作。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/111837?site