当前位置:   article > 正文

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

c# 自定义序列化 getobjectdata 兼容

5、自定义序列化
如果你希望让用户对类进行串行化,但是对数据流的组织方式不完全满意,那么可以通过在自定义类中实现接口来自定义串行化行为。这个接口只有一个方法,GetObjectData.这个方法用于将对类对象进行串行化所需要的数据填进SerializationInfo对象。你使用的格式化器将构造SerializationInfo对象,然后在串行化时调用GetObjectData.如果类的父类也实现了ISerializable,那么应该调用GetObjectData的父类实现。
 
  如果你实现了ISerializable,那么还必须提供一个具有特定原型的构造器,这个构造器的参数列表必须与GetObjectData相同。这个构造器应该被声明为私有的或受保护的,以防止粗心的开发人员直接使用它。

[csharp]  view plain  copy
  1. public enum SexType  
  2.     {  
  3.         Male,  
  4.         Female  
  5.     }  
  6.     [Serializable()]  
  7.     public class Item  
  8.     {  
  9.         private int id;  
  10.         public int ID  
  11.         {  
  12.             get { return id; }  
  13.             set { id = value; }  
  14.         }  
  15.   
  16.         private string name;  
  17.         public string Name  
  18.         {  
  19.             get { return name; }  
  20.             set { name = value; }  
  21.         }  
  22.   
  23.         public Item() { } // 必须有默认构造函数,才能xml序列化  
  24.         public Item(int id, string name)  
  25.         {  
  26.             ID = id;  
  27.             Name = name;  
  28.         }  
  29.   
  30.         public override string ToString()  
  31.         {  
  32.             return id.ToString() + "," + name;  
  33.         }  
  34.   
  35.         public static Item ToObject(string str)  
  36.         {  
  37.             Item item = new Item();  
  38.             item.id = int.Parse(str.Split(',')[0]);  
  39.             item.name = str.Split(',')[1];  
  40.             return item;  
  41.         }  
  42.     }  
  43.     [Serializable()]  
  44.     public class ItemSub : Item  
  45.     {  
  46.         private SexType sex;  
  47.         public SexType Sex  
  48.         {  
  49.             get { return sex; }  
  50.             set { sex = value; }  
  51.         }  
  52.   
  53.         public ItemSub() { } // 必须有默认构造函数,才能xml序列化  
  54.         public ItemSub(int id, string name, SexType sex)  
  55.             : base(id, name)  
  56.         {  
  57.             this.sex = sex;  
  58.         }  
  59.     }  
  60.   
  61.     [Serializable()]  
  62.     public class ListBuffer : ISerializable  
  63.     {  
  64.         private List<string> list = new List<string>();  
  65.   
  66.         public void Add(string str)  
  67.         {  
  68.             lock (list)  
  69.             {  
  70.                 list.Add(str);  
  71.             }  
  72.         }  
  73.   
  74.         public void Remove(string str)  
  75.         {  
  76.             lock (list)  
  77.             {  
  78.                 list.Remove(str);  
  79.             }  
  80.         }  
  81.   
  82.         public int Count  
  83.         {  
  84.             get { return list.Count; }  
  85.         }  
  86.   
  87.         /// <summary>  
  88.         /// 自定义序列化方法  
  89.         /// 为了让子类能定义自定义序列化方法,这里必须标记为virtual  
  90.         /// 从接口中继承而来的方法没有任何修饰符,必须继承后自己添加  
  91.         /// 如果这个方法不标记为virtual,那么子类将不能重写自己的序列化方法  
  92.         /// </summary>  
  93.         /// <param name="info"></param>  
  94.         /// <param name="ctxt"></param>  
  95.         public virtual void GetObjectData(SerializationInfo info, StreamingContext ctxt)  
  96.         {  
  97.             int index = 0;  
  98.             foreach (string str in list)  
  99.             {  
  100.                 // 由于是列表,所以不能给每个对象分配一个固定的键名,所以这里用索引序号代替  
  101.                 info.AddValue(index.ToString(), str);  
  102.                 index++;  
  103.             }  
  104.         }  
  105.   
  106.         public ListBuffer() { }  
  107.         protected ListBuffer(SerializationInfo info, StreamingContext ctxt)  
  108.         {  
  109.             int i = 0;  
  110.             SerializationInfoEnumerator irator = info.GetEnumerator();  
  111.             while (irator.MoveNext())  
  112.             {  
  113.                 if (irator.Name.IndexOf("sub") == -1) // 这里先要过滤掉子类中添加的键名,否则会异常  
  114.                 {  
  115.                     // 反序列化,从流中找到可用的键  
  116.                     object o = info.GetValue(i.ToString(), typeof(string));  
  117.                     if (o != null)  
  118.                         list.Add(o.ToString());  
  119.                 }  
  120.   
  121.                 i++;  
  122.             }  
  123.         }  
  124.     }  
  125.     [Serializable()]  
  126.     public class ListBufferSub : ListBuffer  
  127.     {  
  128.         private List<Item> listItem = new List<Item>();  
  129.   
  130.         public void AddItem(Item item)  
  131.         {  
  132.             lock (listItem)  
  133.             {  
  134.                 listItem.Add(item);  
  135.             }  
  136.         }  
  137.   
  138.         public void Remove(Item item)  
  139.         {  
  140.         }  
  141.   
  142.         /// <summary>  
  143.         /// 子类要增加自己的序列化对象,必须重载基类的GetObjectData  
  144.         /// 再次重申一遍,基类从接口继承的GetObjectData默认不是virtual的,必须手动加上virtual修饰符  
  145.         /// </summary>  
  146.         /// <param name="info"></param>  
  147.         /// <param name="ctxt"></param>  
  148.         public override void GetObjectData(SerializationInfo info, StreamingContext ctxt)  
  149.         {  
  150.             base.GetObjectData(info, ctxt); // 先调用基类的自定义序列化方法  
  151.   
  152.             int index = base.Count; // 索引序号从基类的索引序号开始  
  153.             foreach (Item item in listItem) // 然后再将子类自己的序列化成员添加到序列流中  
  154.             {  
  155.                 info.AddValue("sub"+index.ToString(), item);  
  156.                 index++;  
  157.             }  
  158.         }  
  159.   
  160.         public ListBufferSub() { }  
  161.         protected ListBufferSub(SerializationInfo info, StreamingContext ctxt)  
  162.             : base(info, ctxt) // 先调用基类的反序列化构造方法(序列化流中包含基类和子类的键,在使用是要注意剔除)  
  163.         {  
  164.             int i = 0;  
  165.             SerializationInfoEnumerator irator = info.GetEnumerator();  
  166.             while (irator.MoveNext())  
  167.             {  
  168.                 if (irator.Name.IndexOf("sub") != -1) // 找到子类的键  
  169.                 {  
  170.                     object o = info.GetValue("sub" + i.ToString(), typeof(Item)); // 获得子类的对象  
  171.                     if (o != null && o is Item)  
  172.                         listItem.Add(o as Item);  
  173.                 }  
  174.                 i++;  
  175.             }  
  176.         }  
  177.     }  
  178.   
  179.     [Serializable()]  
  180.     public class BinarySerialize  
  181.     {  
  182.         private int id;  
  183.         public int ID  
  184.         {  
  185.             get { return id; }  
  186.             set { id = value; }  
  187.         }  
  188.   
  189.         private string name;  
  190.         public string Name  
  191.         {  
  192.             get { return name; }  
  193.             set { name = value; }  
  194.         }  
  195.   
  196.         private SexType sex;  
  197.         public SexType Sex  
  198.         {  
  199.             get { return sex; }  
  200.             set { sex = value; }  
  201.         }  
  202.   
  203.         private List<string> listStr;  
  204.         public List<string> ListStr  
  205.         {  
  206.             get { return listStr; }  
  207.             set { listStr = value; }  
  208.         }  
  209.   
  210.         private List<Item> listItem;  
  211.         public List<Item> ListItem  
  212.         {  
  213.             get { return listItem; }  
  214.             set { listItem = value; }  
  215.         }  
  216.   
  217.         private ListBuffer buffer = new ListBuffer();  
  218.         public ListBuffer Buffer  
  219.         {  
  220.             get { return buffer; }  
  221.             set { buffer = value; }  
  222.         }  
  223.   
  224.         private ListBufferSub bufferSub = new ListBufferSub();  
  225.         public ListBufferSub BufferSub  
  226.         {  
  227.             get { return bufferSub; }  
  228.             set { bufferSub = value; }  
  229.         }  
  230.   
  231.         private List<ListBuffer> listBuffer;  
  232.         public List<ListBuffer> ListBuffer  
  233.         {  
  234.             get { return listBuffer; }  
  235.             set { listBuffer = value; }  
  236.         }  
  237.     }  
  238.   
  239.     public sealed class ConfigurationManagerBinarySerialize  
  240.     {  
  241.         private static string path = System.Windows.Forms.Application.StartupPath + "\\BinarySerialize.bat";  
  242.   
  243.         public static BinarySerialize Get()  
  244.         {  
  245.             if (!File.Exists(path))  
  246.                 return null;  
  247.   
  248.             BinaryFormatter b = new BinaryFormatter();  
  249.             using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))  
  250.             {  
  251.                 return (BinarySerialize)b.Deserialize(fs);  
  252.             }  
  253.         }  
  254.   
  255.         public static void Set(BinarySerialize hr)  
  256.         {  
  257.             BinaryFormatter b = new BinaryFormatter();  
  258.             using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))  
  259.             {  
  260.                 b.Serialize(fs, hr);  
  261.             }  
  262.         }  
  263.     }  

备注:

这里写了一个很复杂的自定义序列化的例子,其中包含集合,继承等关系。

对于需要自定义序列化的类,需要使其继承ISerializable接口,实现GetObjectData函数以及添加一个带相同参数的构造函数。

序列化时,系统调用GetObjectData保存信息,反序列化时,系统调用带参数的构造函数创建对象。

如果基类自定义了序列化,那么子类在自定义序列化方法时首先要调用基类的自定义方法,然后再进行自己的序列化操作。

基类的GetObjectData方法必须注明是virtual的,否则子类无法正常序列化。

自定义序列化必须使用BinaryFormatter进行序列化操作,xml无法正常工作。

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

闽ICP备14008679号