对象与Xml的相互转化

    .Net中的XmlSerializer非常好用，但是有时候也不能完全满足要求。比如XmlSerializer完全按照对象内容展开，而不管引用关系，造成在反序列化后对象结构和原始的会不一致，如果循环引用还会出现死循环；需要显式制定对象中所有的自定义类型，不够方便；不支持范型，不能用接口作为变量类型等等。

    自己写了一段程序，某些时候用起来比较方便，也为了熟悉一下Xml操作。很久以前写的了，现在看一下还是有一些不足之处，以后有需要再修改吧。

1. using   System; 
2. using   System.Collections.Generic; 
3. using   System.Text; 
4. using   System.Xml; 
5. using   System.IO; 
6. using   System.Reflection; 
7. using   System.Runtime.Serialization; 
8. using   System.Collections; 
10. namespace   System 
11. { 
12.         public   static   class   XMLConvert 
13.         { 
14.                 private   const   string   tag_reference   =   "ref "; 
15.                 private   const   string   tag_type   =   "type "; 
16.                 private   const   string   tag_param   =   "params "; 
17.                 private   const   char   char_left   =   '( '; 
18.                 private   const   char   char_right   =   ') '; 
20.                 private   static   Assembly[]   assemblies   =   AppDomain.CurrentDomain.GetAssemblies(); 
21.                 
22.                 public   static   string   ToXML(object   o) 
23.                 { 
24.                         return   ToXML( "class ",   o); 
25.                 } 
27.                 public   static   string   ToXML(string   name,   object   o) 
28.                 { 
29.                         StringBuilder   stringBuilder   =   new   StringBuilder(); 
30.                         XmlTextWriter   xmlWriter   =   new   XmlTextWriter(new   StringWriter(stringBuilder)); 
31.                         xmlWriter.Formatting   =   Formatting.Indented; 
32.                         xmlWriter.WriteStartDocument(); 
33.                         ToXML(name,   o,   xmlWriter,   new   Hashtable()); 
34.                         xmlWriter.WriteEndDocument(); 
35.                         return   stringBuilder.ToString(); 
36.                 } 
38.                 public   static   object   ToObject(string   strXML) 
39.                 { 
40.                         XmlDocument   xml   =   new   XmlDocument(); 
41.                         xml.LoadXml(strXML); 
42.                         return   ToObject(xml); 
43.                 } 
45.                 public   static   object   ToObject(XmlDocument   xml) 
46.                 { 
47.                         Hashtable   refMap   =   new   Hashtable(xml.ChildNodes.Count   *   4); 
48.                         object   value   =   ToObject(xml.LastChild,   refMap); 
49.                         return   value; 
50.                 } 
52.                 private   static   void   ToXML(string   name,   object   value,   XmlWriter   xmlWriter,   Hashtable   refMap) 
53.                 { 
54.                         xmlWriter.WriteStartElement(name); 
55.                         if   (value   !=   null) 
56.                         { 
57.                                 if   (refMap.ContainsKey(new   Ref(value))) 
58.                                 { 
59.                                         xmlWriter.WriteAttributeString(tag_reference,   refMap[new   Ref(value)].ToString()); 
60.                                 } 
61.                                 else 
62.                                 { 
63.                                         Type   type   =   value.GetType(); 
64.                                         TypeToXML(type,   xmlWriter); 
65.                                         if   (!type.IsValueType) 
66.                                         { 
67.                                                 xmlWriter.WriteAttributeString(tag_reference,   refMap.Count.ToString()); 
68.                                                 refMap.Add(new   Ref(value),   refMap.Count); 
69.                                         } 
71.                                         if   (type.IsPrimitive   ||   type.Equals(typeof(string))) 
72.                                         { 
73.                                                 xmlWriter.WriteString(Convert.ToString(value)); 
74.                                         } 
75.                                         else   if   (type.IsArray) 
76.                                         { 
77.                                                 foreach   (object   subvalue   in   (value   as   Array)) 
78.                                                 { 
79.                                                         ToXML( "element ",   subvalue,   xmlWriter,   refMap); 
80.                                                 } 
81.                                         } 
82.                                         else 
83.                                         { 
84.                                                 ToXML(type,   value,   xmlWriter,   refMap); 
85.                                         } 
86.                                 } 
87.                         } 
88.                         xmlWriter.WriteEndElement(); 
89.                 } 
90.  private   static   void   ToXML(Type   type,   object   value,   XmlWriter   xmlWriter,   Hashtable   refMap) 
91.                 { 
92.                         if   (type   ==   null   ||   type.Equals(typeof(object)))   return; 
93.                         FieldInfo[]   fields   =   type.GetFields(BindingFlags.GetField   |   BindingFlags.Instance   |   BindingFlags.Public   |   BindingFlags.NonPublic); 
94.                         foreach   (FieldInfo   field   in   fields) 
95.                         { 
96.                                 ToXML(field.Name,   field.GetValue(value),   xmlWriter,   refMap); 
97.                         } 
98.                         ToXML(type.BaseType,   value,   xmlWriter,   refMap); 
99.                 } 
101.                 private   static   void   TypeToXML(Type   type,   XmlWriter   xmlWriter) 
102.                 { 
103.                         if   (type.IsGenericType) 
104.                         { 
105.                                 Type   genericType   =   type.GetGenericTypeDefinition(); 
106.                                 xmlWriter.WriteAttributeString(tag_type,   genericType.FullName); 
107.                                 Type[]   genericArguments   =   type.GetGenericArguments(); 
108.                                 xmlWriter.WriteAttributeString(tag_param,   ToParamsName(genericArguments)); 
109.                         } 
110.                         else 
111.                         { 
112.                                 xmlWriter.WriteAttributeString(tag_type,   type.FullName); 
113.                         } 
114.                 } 
116.                 private   static   string   ToParamsName(Type[]   genericArguments) 
117.                 { 
118.                         string[]   names   =   new   string[genericArguments.Length]; 
119.                         for   (int   i   =   0;   i   <   genericArguments.Length;   i++) 
120.                         { 
121.                                 if   (genericArguments[i].IsGenericType) 
122.                                         names[i]   =   genericArguments[i].GetGenericTypeDefinition().FullName   +   char_left   +   ToParamsName(genericArguments[i].GetGenericArguments())   +   char_right; 
123.                                 else 
124.                                         names[i]   =   genericArguments[i].FullName; 
125.                         } 
126.                         return   String.Join( ",   ",   names); 
127.                 } 
129.                 private   static   object   ToObject(XmlNode   node,   Hashtable   refMap) 
130.                 { 
131.                         if   (node   ==   null   ||   node.Attributes.Count   ==   0)   return   null; 
132.                         if   (node.Attributes[tag_reference]   !=   null   &&   refMap[Int32.Parse(node.Attributes[tag_reference].Value)]   !=   null)   return   refMap[Int32.Parse(node.Attributes[tag_reference].Value)]; 
134.                         Type   type   =   GetType(node.Attributes[tag_type].Value); 
135.                         if   (type.IsGenericTypeDefinition) 
136.                         { 
137.                                 string   paramName   =   node.Attributes[tag_param].Value; 
138.                                 type   =   GetGenericType(type,   paramName); 
139.                         } 
141.                         object   value   =   null; 
142.                         if   (type.Equals(typeof(IntPtr))) 
143.                         { 
144.                                 value   =   (IntPtr)Convert.ToInt32(node.InnerText); 
145.                         } 
146.                         else   if   (type.IsPrimitive   ||   type.Equals(typeof(string))) 
147.                         { 
148.                                 value   =   Convert.ChangeType(node.InnerText,   type); 
149.                         } 
150.                         else   if   (type.IsArray) 
151.                         { 
152.                                 value   =   Array.CreateInstance(type.GetElementType(),   node.ChildNodes.Count); 
153.                         } 
154.                         else 
155.                         { 
156.                                 value   =   FormatterServices.GetUninitializedObject(type); 
157.                         } 
159.                         if   (node.Attributes[tag_reference]   !=   null)   refMap[Int32.Parse(node.Attributes[tag_reference].Value)]   =   value; 
161.                         if   (type.Equals(typeof(IntPtr)))   {   } 
162.                         else   if   (type.IsPrimitive   ||   type.Equals(typeof(string)))   {   } 
163.                         else   if   (type.IsArray) 
164.                         { 
165.                                 for   (int   i   =   0;   i   <   node.ChildNodes.Count;   i++) 
166.                                 { 
167.                                         (value   as   Array).SetValue(ToObject(node.ChildNodes[i],   refMap),   i); 
168.                                 } 
169.                         } 
170.                         else 
171.                         { 
172.                                 foreach   (XmlNode   xmlnode   in   node.ChildNodes) 
173.                                 { 
174.                                         FieldInfo   field   =   GetField(type,   xmlnode.Name); 
175.                                         field.SetValue(value,   ToObject(xmlnode,   refMap)); 
176.                                 } 
177.                         } 
178.                         return   value; 
179.                 } 
180. private   static   Type   GetType(string   name) 
181.                 { 
182.                         int   index1   =   name.IndexOf(char_left); 
183.                         int   index2   =   name.LastIndexOf(char_right); 
184.                         if   (index1   <   0) 
185.                         { 
186.                                 Type   type   =   Type.GetType(name); 
187.                                 if   (type   ==   null) 
188.                                 { 
189.                                         foreach   (Assembly   assembly   in   assemblies) 
190.                                         { 
191.                                                 type   =   assembly.GetType(name); 
192.                                                 if   (type   !=   null)   break; 
193.                                         } 
194.                                 } 
195.                                 return   type; 
196.                         } 
197.                         else 
198.                         { 
199.                                 return   GetGenericType(GetType(name.Substring(0,   index1)),   name.Substring(index1   +   1,   index2   -   index1   -   1)); 
200.                         } 
201.                 } 
203.                 private   static   FieldInfo   GetField(Type   type,   string   name) 
204.                 { 
205.                         FieldInfo   field   =   null; 
206.                         while   (field   ==   null   &&   type   !=   null) 
207.                         { 
208.                                 field   =   type.GetField(name,   BindingFlags.Instance   |   BindingFlags.Public   |   BindingFlags.NonPublic); 
209.                                 type   =   type.BaseType; 
210.                         } 
211.                         return   field; 
212.                 } 
214.                 private   static   Type   GetGenericType(Type   type,   string   param) 
215.                 { 
216.                         string[]   paramNames   =   Split(param,   ', ',   char_left,   char_right); 
217.                         Type[]   paramTypes   =   new   Type[paramNames.Length]; 
218.                         for   (int   i   =   0;   i   <   paramNames.Length;   i++) 
219.                         { 
220.                                 paramTypes[i]   =   GetType(paramNames[i]); 
221.                         } 
222.                         return   type.MakeGenericType(paramTypes); 
223.                 } 
225.                 private   static   string[]   Split(string   str,   char   separator,   char   left,   char   right) 
226.                 { 
227.                         List <string>   results   =   new   List <string> (str.Length   /   10); 
228.                         int   start   =   0; 
229.                         for   (int   i   =   0,   stack   =   0;   i   <   str.Length;   i++) 
230.                         { 
231.                                 if   (str[i]   ==   separator   &&   stack   ==   0) 
232.                                 { 
233.                                         results.Add(str.Substring(start,   i   -   start)); 
234.                                         start   =   i   +   1; 
235.                                 } 
236.                                 if   (str[i]   ==   left)   stack++; 
237.                                 if   (str[i]   ==   right)   stack--; 
238.                         } 
239.                         if   (start   <   str.Length)   results.Add(str.Substring(start)); 
240.                         return   results.ToArray(); 
241.                 } 
243.                 class   Ref 
244.                 { 
245.                         private   object   value   =   null; 
247.                         public   Ref(object   o) 
248.                         { 
249.                                 value   =   o; 
250.                         } 
252.                         public   override   bool   Equals(object   obj) 
253.                         { 
254.                                 if   (obj   is   Ref   &&   ReferenceEquals(value,   (obj   as   Ref).value))   return   true; 
255.                                 else   return   false; 
256.                         } 
258.                         public   override   int   GetHashCode() 
259.                         { 
260.                                 if   (value   !=   null)   return   value.GetHashCode(); 
261.                                 else   return   0; 
262.                         } 
263.                 } 
264.         } 
265. }