自定義Object與XML互換(序列化)

哈哈哈哈哈我撒發表於2010-05-05
原文網址 : https://blog.csdn.net/adi_liu/article/details/5559444
ObjectXML

 

反射真是個好東西,值得去深入學習.今天利用它實現物件的序列化與反序列化.由於是基於可互換的原則,在沒有找到反序列化之前,拋棄了部分通用的做法.

如果只是簡單的將物件序列化成為XML,本是很方便的,但在考慮需要反序列化後,不得不考慮很多的問題.

比如,序列化值型別(Type.IsValueType為true)的型別時,基本只需要簡單的ToString()就可以.但如果想返序列化的話,有些型別就得去考慮,比如,日期的字串格式.我是通過下面的方式,在確定的區域和日期格式中實現日期與字串之間做轉換:

 

  1. static DateTimeFormatInfo dtfi = new CultureInfo("zh-CN", false).DateTimeFormat;  
  2. public override void ToXml(object val, StringBuilder builder)  
  3. {  
  4.     builder.AppendFormat("{0}", ((DateTime)val).ToString(dtfi));  
  5. }  
  6.   
  7. public override Object ToObject(Type type, XmlNode node)  
  8. {  
  9.     String val = node.InnerText;  
  10.     return DateTime.Parse(val, dtfi);  
  11. }  

 

在實現功能時,集合無疑是最麻煩的,特別有了泛型之後,規則就更復雜了.加上考慮介面型別的話,就難上加難.像在確定集合中元素的型別,也不一樣.如:

陣列元素型別: Type.GetElementType()

泛型的T型別:Type.GetGenericArguments()

而陣列的元素是一個Type,但泛型的T型別卻是Type[].特別在確定System.Collections.CollectionBase的元素型別時,沒有找到可從Type中反射的方法,轉換使用下面的方式確定:

 

  1. System.Collections.IEnumerator tor = ((IEnumerable)val).GetEnumerator();  
  2. if (tor.MoveNext())  
  3. {  
  4.     Type t = tor.Current.GetType();  
  5. }  

 

這個其實是確定集合元素型別的通用方法,但它在反序列化時卻不能使用.因為這樣做只能在集合不為空時才能使用,而反序列化時,指定的集合卻有可能是空的.所以這個取出來的型別,需要將它的所屬程式集與型別名稱儲存下來,比如在節點中以itype的屬性把它儲存下來.這樣做又增加了程式的複雜度.

同時,在反序列化介面型別的屬性時,也有可能遇到相似的問題,比如如何確定介面的實現型別?這個利用反射是做不到的.那麼又只好把實現型別的相關資訊在序列化時儲存了,那不儲存到ctype屬性值中去吧.

有了一大堆並不完全相容的轉換方法後,如何將程式碼的複雜度儘量降低呢?

在這個序列化與反序列中,我們需要確定哪些轉換方法適用於哪些型別,那麼就讓他主動告訴呼叫者吧.定義一個負責轉換的基類:Switcher,它的作用是定義規則,實現最通用的做法,具體的事務由更詳細的實現類來確定如何進行.下面是Switcher的全部程式碼:

 

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Reflection;  
  5. using System.Xml;  
  6.   
  7. namespace Guaik.Serialization.Xml  
  8. {  
  9.     /// <summary>  
  10.     /// 轉換器  
  11.     /// </summary>  
  12.     public class Switcher  
  13.     {  
  14.         /// <summary>  
  15.         /// 得到型別的屬性列表  
  16.         /// </summary>  
  17.         public virtual PropertyInfo[] GetProperties(Type t)  
  18.         {  
  19.             return t.GetProperties();  
  20.         }  
  21.   
  22.         /// <summary>  
  23.         /// 檢查是否可使用此轉換器  
  24.         /// </summary>  
  25.         public virtual bool IsSwitcher(Type t)  
  26.         {  
  27.             return true;  
  28.         }  
  29.   
  30.         /// <summary>  
  31.         /// 轉換為MXL  
  32.         /// </summary>  
  33.         public virtual void ToXml(Int32 level, String name, Type type, Object val, StringBuilder builder)  
  34.         {  
  35.             String sp = " ".PadLeft(level * 2);  
  36.             builder.AppendFormat("{0}<{1}>{2}</{1}>", sp, name, val).AppendLine();  
  37.         }  
  38.   
  39.         public virtual void ToXml(Object val, StringBuilder builder)  
  40.         {  
  41.             builder.AppendFormat("{0}", val);  
  42.         }  
  43.   
  44.         /// <summary>  
  45.         /// 轉換為物件  
  46.         /// </summary>  
  47.         public virtual Object ToObject(Type type, XmlNode node)  
  48.         {  
  49.             return Convert.ChangeType(node.InnerText, type);  
  50.         }  
  51.     }  
  52. }  

 

 

可以看到,其實主要是實現了三個方法:

IsSwitcher(Type t)  這個用來告訴使用者,你這個轉換器是否適用於Type型別?

ToXml(.....)  這個用來將物件轉換為XML

ToObject(Type type, XmlNode node)  負責將node中的序列化的內容轉換為type型別返回

GetProperties(Type t)  現在只是簡單的呼叫Type型別的方法返回,而以後可以定義相關的規則,可以在序列化時實現隱藏屬性,重新命名等規則

在Switcher中實現的方法都是相對通用的,實現類中,只需要重寫相關的方法則可.比如列舉是不可以像上面那樣,使用Convert.ChangeType來轉換的.因此需要定義一個用於處理列舉的Switcher,如下:

 

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Reflection;  
  5. using System.Xml;  
  6.   
  7. namespace Guaik.Serialization.Xml  
  8. {  
  9.     /// <summary>  
  10.     /// 列舉  
  11.     /// </summary>  
  12.     public class EnumSwitcher : Switcher  
  13.     {  
  14.         public override bool IsSwitcher(Type t)  
  15.         {  
  16.             return t.IsEnum;  
  17.         }  
  18.   
  19.         public override Object ToObject(Type type, XmlNode node)  
  20.         {  
  21.             String val = node.InnerText;  
  22.             return Enum.Parse(type, val);  
  23.         }  
  24.     }  
  25. }  

 

 

實現的內容也非常簡單.由於看到實現一個不相容的型別還是相對方便的. 而在實現將資料序列化與反序列化中,也可以保持程式碼的簡潔,下面是實現轉換的類:

 

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Reflection;  
  5. using System.Xml;  
  6.   
  7. namespace Guaik.Serialization.Xml  
  8. {  
  9.     /// <summary>  
  10.     /// XML持久化  
  11.     /// </summary>  
  12.     public class XmlSerialization  
  13.     {  
  14.         private static Switcher[] Switcher = new Switcher[] {   
  15.             new EnumSwitcher(),  
  16.             new StringSwitcher(),  
  17.             new DateTimeSwitcher(),  
  18.             new ValueTypeSwitcher(),  
  19.             //new GenericSwitcher(),  
  20.             new CollectionSwitcher()  
  21.         };  
  22.   
  23.         private static PropertyInfo FindProperty(Type type, String name)  
  24.         {  
  25.             PropertyInfo[] infos = GetProperties(type);  
  26.             foreach (PropertyInfo info in infos)  
  27.             {  
  28.                 if (info.Name == name) return info;  
  29.             }  
  30.             return null;  
  31.         }  
  32.   
  33.         private static PropertyInfo[] GetProperties(Type t)  
  34.         {  
  35.             return t.GetProperties();  
  36.         }  
  37.   
  38.         private static Switcher GetSwitcher(Type t)  
  39.         {  
  40.             foreach (Switcher sw in Switcher)  
  41.             {  
  42.                 if (sw.IsSwitcher(t))  
  43.                 {  
  44.                     return sw;  
  45.                 }  
  46.             }  
  47.             return null;  
  48.         }  
  49.  
  50.         #region Xml2Object  
  51.         public static Object Xml2Object(Type type, String path)  
  52.         {  
  53.             XmlDocument doc = new XmlDocument();  
  54.             doc.Load(path);  
  55.             return Xml2Object(type, doc);  
  56.         }  
  57.   
  58.         public static Object Xml2Object(Type type, XmlDocument doc)  
  59.         {  
  60.             return Xml2Object(type, doc.SelectSingleNode(type.Name));  
  61.         }  
  62.   
  63.         public static Object Xml2Object(Type type, XmlNode root)  
  64.         {  
  65.             Switcher swr = null;  
  66.   
  67.             swr = GetSwitcher(type);  
  68.             if (swr != null)  
  69.             {  
  70.                 return swr.ToObject(type, root);  
  71.             }  
  72.             else  
  73.             {  
  74.                 Object val = null;  
  75.                 Switcher switcher = null;  
  76.                 PropertyInfo info = null;  
  77.                 Object obj = Activator.CreateInstance(type, true);  
  78.                 foreach (XmlNode node in root.ChildNodes)  
  79.                 {  
  80.                     info = FindProperty(type, node.Name);  
  81.                     if (info != null)  
  82.                     {  
  83.                         switcher = GetSwitcher(info.PropertyType);  
  84.                         val = switcher.ToObject(info.PropertyType, node);  
  85.                         if (val != null)  
  86.                         {  
  87.                             info.GetSetMethod().Invoke(obj, new object[] { val });  
  88.                         }  
  89.                     }  
  90.                 }  
  91.                 return obj;  
  92.             }  
  93.         }  
  94.         #endregion  
  95.  
  96.         #region Object2Xml  
  97.         public static string Object2Xml(Object obj)  
  98.         {  
  99.             Type t = obj.GetType();  
  100.             StringBuilder builder = new StringBuilder();  
  101.             builder.AppendLine("<?xml version=/"1.0/" encoding=/"utf-8/" ?> ");  
  102.   
  103.             builder.AppendFormat("<{0}>", t.Name).AppendLine();  
  104.   
  105.             Object2Xml(1, obj, builder);  
  106.   
  107.             builder.AppendFormat("</{0}>", t.Name).AppendLine();  
  108.   
  109.             return builder.ToString();  
  110.         }  
  111.   
  112.         public static bool Object2Xml(Int32 level, Object obj, StringBuilder builder)  
  113.         {  
  114.             Switcher swr = null;  
  115.             Type t = obj.GetType();  
  116.   
  117.             swr = GetSwitcher(t);  
  118.             if (swr != null)  
  119.             {  
  120.                 swr.ToXml(obj, builder);  
  121.                 return true;  
  122.             }  
  123.             else  
  124.             {  
  125.                 object val = null;  
  126.                 MethodInfo mi = null;  
  127.                 PropertyInfo[] infos = GetProperties(t);  
  128.                 foreach (PropertyInfo info in infos)  
  129.                 {  
  130.                     mi = info.GetGetMethod();  
  131.                     if (mi != null)  
  132.                     {  
  133.                         val = mi.Invoke(obj, null);  
  134.                         if (val != null)  
  135.                         {  
  136.                             swr = GetSwitcher(val.GetType());  
  137.                             if (swr != null)  
  138.                             {  
  139.                                 swr.ToXml(level + 1, info.Name, info.PropertyType, val, builder);  
  140.                             }  
  141.                         }  
  142.                     }  
  143.                 }  
  144.                 return false;  
  145.             }  
  146.         }  
  147.         #endregion  
  148.     }  
  149. }  

 


在這個類中,有三個重要的方法:

Object2Xml(...) 將物件轉換為XML

Xml2Object(...)  將XML轉換為物件,提供了方法過載,方便使用者

GetSwitcher(..)  確定哪個轉換器可用於當前的轉換

GetSwitcher(..)方法中,使用了一個配置表Switcher ,在這裡儲存可用於轉換的轉換器集合.這個集合的次序確定了轉換器的呼叫.

在呼叫方面,也非常簡單,下面是測試程式碼:

 

  1. //型別定義  
  2.     public class User  
  3.     {  
  4.         public string Name { get; set; }  
  5.         public bool Sex { get; set; }  
  6.         public int Age { get; set; }  
  7.         public UserType Type { get; set; }  
  8.         public DateTime CreateAt { get; set; }  
  9.         public String[] Logs{get;set;}  
  10.         public IList<String> List { get; set; }  
  11.         public UserCollection Users { get; set; }  
  12.     }  
  13.   
  14.     public enum UserType  
  15.     {  
  16.         Login,  
  17.         Logout  
  18.     }  
  19.   
  20.     /// <summary>  
  21.     /// 資料庫集合  
  22.     /// </summary>  
  23.     public class UserCollection : CollectionBase  
  24.     {  
  25.         public User this[int index]  
  26.         {  
  27.             get  
  28.             {  
  29.                 return ((User)List[index]);  
  30.             }  
  31.             set  
  32.             {  
  33.                 List[index] = value;  
  34.             }  
  35.         }  
  36.   
  37.         public User this[string name]  
  38.         {  
  39.             get  
  40.             {  
  41.                 foreach (User d in this)  
  42.                 {  
  43.                     if (d.Name.ToLower() == name.ToLower())  
  44.                     {  
  45.                         return (User)d;  
  46.                     }  
  47.                 }  
  48.                 return null;  
  49.             }  
  50.         }  
  51.   
  52.         public int Add(User value)  
  53.         {  
  54.             return (List.Add(value));  
  55.         }  
  56.   
  57.         public int IndexOf(User value)  
  58.         {  
  59.             return (List.IndexOf(value));  
  60.         }  
  61.   
  62.         public void Insert(int index, User value)  
  63.         {  
  64.             List.Insert(index, value);  
  65.         }  
  66.   
  67.         public void Remove(User value)  
  68.         {  
  69.             List.Remove(value);  
  70.         }  
  71.   
  72.         public bool Contains(User value)  
  73.         {  
  74.             // If value is not of type User, this will return false.  
  75.             return (List.Contains(value));  
  76.         }  
  77.   
  78.         protected override void OnInsert(int index, Object value)  
  79.         {  
  80.             // Insert additional code to be run only when inserting values.  
  81.         }  
  82.   
  83.         protected override void OnRemove(int index, Object value)  
  84.         {  
  85.             // Insert additional code to be run only when removing values.  
  86.         }  
  87.   
  88.         protected override void OnSet(int index, Object oldValue, Object newValue)  
  89.         {  
  90.             // Insert additional code to be run only when setting values.  
  91.         }  
  92.   
  93.         protected override void OnValidate(Object value)  
  94.         {  
  95.             if (!(value is User))  
  96.                 throw new ArgumentException("value must be of type User.", "value");  
  97.         }  
  98.     }  
  99.   
  100.   
  101.   
  102. //序列化  
  103.         User user = new User();  
  104.             user.Name = "鄧銘武";  
  105.             user.Sex = true;  
  106.             user.Age = 20;  
  107.             user.Type = UserType.Logout;  
  108.             user.CreateAt = DateTime.Now;  
  109.             user.Logs = new string[] {  
  110.                 "登陸",  
  111.                 "登出"  
  112.             };  
  113.             user.List = new List<String>();  
  114.             user.List.Add("Name1");  
  115.             user.List.Add("Name2");  
  116.             user.List.Add("Name3");  
  117.   
  118.             user.Users = new UserCollection();  
  119.   
  120.             User su = new User();  
  121.             su.Name = "鄧銘武1";  
  122.             user.Users.Add(su);  
  123.             su = new User();  
  124.             su.Name = "鄧銘武2";  
  125.             user.Users.Add(su);  
  126.             su = new User();  
  127.             su.Name = "鄧銘武3";  
  128.             user.Users.Add(su);  
  129.   
  130.             string xml = XmlSerialization.Object2Xml(user);  
  131.             richTextBox1.Text = xml;  
  132.   
  133.   
  134. //反序列化  
  135.         User user = new User();  
  136.             XmlDocument doc = new XmlDocument();  
  137.             doc.LoadXml(richTextBox1.Text);  
  138.   
  139.             Object obj = (User)XmlSerialization.Xml2Object(typeof(User), doc);  

 

 

從上面可以看到,序列化與反序列化呼叫時,只需要呼叫一句程式碼就可以實現,過程非常方便.目前它可以支援C#型別系統中的所有基本型別,IList介面,IList<T>介面和CollectionBase集合,陣列等.如果想實現其它型別的轉換操作,可以通過實現Switcher重新配置XmlSerialization.Switcher表就可以達到目的.

 

相關文章