IT狗

C# 串行化与反串行化--运用BinaryFormatter进行串行化

1、运用BinaryFormatter进行串行化

串行化的文件是二进制格式,险些一切的对象都能顺遂串行化,现在还没有发明不可以串行化的对象。

[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.     [Serializable()]  
  88.     public class ListBufferSub : ListBuffer  
  89.     {  
  90.         private List<Item> listItem = new List<Item>();  
  91.   
  92.         public void AddItem(Item item)  
  93.         {  
  94.             lock (listItem)  
  95.             {  
  96.                 listItem.Add(item);  
  97.             }  
  98.         }  
  99.   
  100.         public void Remove(Item item)  
  101.         {  
  102.         }  
  103.     }  
  104.   
  105.     [Serializable()]  
  106.     public class BinarySerialize  
  107.     {  
  108.         private int id;  
  109.         public int ID  
  110.         {  
  111.             get { return id; }  
  112.             set { id = value; }  
  113.         }  
  114.   
  115.         private string name;  
  116.         public string Name  
  117.         {  
  118.             get { return name; }  
  119.             set { name = value; }  
  120.         }  
  121.   
  122.         private SexType sex;  
  123.         public SexType Sex  
  124.         {  
  125.             get { return sex; }  
  126.             set { sex = value; }  
  127.         }  
  128.   
  129.         private List<string> listStr;  
  130.         public List<string> ListStr  
  131.         {  
  132.             get { return listStr; }  
  133.             set { listStr = value; }  
  134.         }  
  135.   
  136.         private List<Item> listItem;  
  137.         public List<Item> ListItem  
  138.         {  
  139.             get { return listItem; }  
  140.             set { listItem = value; }  
  141.         }  
  142.   
  143.         private ListBuffer buffer = new ListBuffer();  
  144.         public ListBuffer Buffer  
  145.         {  
  146.             get { return buffer; }  
  147.             set { buffer = value; }  
  148.         }  
  149.   
  150.         private ListBufferSub bufferSub = new ListBufferSub();  
  151.         public ListBufferSub BufferSub  
  152.         {  
  153.             get { return bufferSub; }  
  154.             set { bufferSub = value; }  
  155.         }  
  156.   
  157.         private List<ListBuffer> listBuffer;  
  158.         public List<ListBuffer> ListBuffer  
  159.         {  
  160.             get { return listBuffer; }  
  161.             set { listBuffer = value; }  
  162.         }  
  163.     }  
  164.   
  165.     public sealed class ConfigurationManagerBinarySerialize  
  166.     {  
  167.         private static string path = System.Windows.Forms.Application.StartupPath + "//BinarySerialize.bat";  
  168.   
  169.         public static BinarySerialize Get()  
  170.         {  
  171.             if (!File.Exists(path))  
  172.                 return null;  
  173.   
  174.             BinaryFormatter b = new BinaryFormatter();  
  175.             using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))  
  176.             {  
  177.                 return (BinarySerialize)b.Deserialize(fs);  
  178.             }  
  179.         }  
  180.   
  181.         public static void Set(BinarySerialize hr)  
  182.         {  
  183.             BinaryFormatter b = new BinaryFormatter();  
  184.             using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))  
  185.             {  
  186.                 b.Serialize(fs, hr);  
  187.             }  
  188.         }  
  189.     }  

备注:

不论是何等庞大的类,BinaryFormatter老是可以准确的进行序列化和反序列化操纵,并且不须要做任何非凡的处置。以是关于大型的类,须要序列化时,优先挑选BinaryFormatter。

此文由 IT狗 编辑,本网站所发布展示的作品/文章版权归原作者所有,任何商业用途均须联系作者!

相关推荐

评论 暂无评论