XmlAttribute与实体的转换和匹配方案（附源码）

一、前言

可扩展标记语言 (XML) 是具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。XML是用来存储数据的，重在数据本身。本文中的代码是几个月前整理的，最近几个月的时间很少写随笔，除了工作以外，主要还是忙于整理自己的框架。这篇随笔主要是针对于XML的特性Attribute与实体之间的匹配与转换，其中的内容包括反射、XML以及LinqToXml，代码的内容也是想到什么就写什么，纯属练习下手感，仅供参考。下一篇随笔将以另外的形式来转换Xml为对象实体，当然，也是以反射为主，和本随笔中的思路差不多，主要是XML的格式和解决方案不同而已。对于如何将对象转换成Xml的话，主要还是看情况，仅仅转换简单的对象的话，直接反射就可以生成。对于复杂的对象的话，可以采用dynamic，树结构和递归算法的方案来定制XML。

二、类图设计

该处的主要思路为：通过反射将与类名（类特性名称或者类名）的节点匹配，然后匹配属性（属性特性名称或者属性名称）值。反之，则遍历实体对象的属性，设置相应的XML。本来还想细化一下匹配与转换操作的，但是该类的EA文件不知道放在哪里了，只有设计的截图还在，XO。相关类图设计如下：

 

 PropertyAttribute主要设置属性的特性名称，用于转换过程设置属性的别名，同时匹配过程中匹配XML的特性与属性的名称。

 ClassAttribute主要设置类的特性名称，用于转换过程设置类的别名，同时匹配过程中匹配XML的节点与类的名称。

 StringExtension主要是字符串的扩展方法。

 FuncDictionary主要转换字符串为特定类型的值。

 XmlAttributeUtility主要转换实体对象为XML以及匹配XML为实体对象，其中还包括一些其他基本操作。

三、具体实现

先看下FuncDictionary，该类主要通过异步委托将字符串转换成相应的简单类型，所有实现围绕该类进行相关操作。FuncDictionary基本涵盖了C#中的所有简单类型，可以将字符串转换成这些简单类型。

主要方法为：public object DynamicInvoke(Type type, string arg)，通过传入的类型和字符串值，可以转换成相应的Object值。属性Dictionary中涵盖了所有简单类型转换的委托操作。代码如下：

 1     public class FuncDictionary
 2     {
 3         public static IDictionary<Type, Delegate> Dictionary
 4         {
 5             get;
 6             private set;
 7         }
 8 
 9         static FuncDictionary()
10         {
11             if (FuncDictionary.Dictionary == null)
12             {
13                 FuncDictionary.Dictionary = CreateDictionary();
14             }
15         }
16 
17         public object DynamicInvoke(Type type, string arg)
18         {
19             if (type == null)
20             {
21                 return null;
22             }
23 
24             if (FuncDictionary.Dictionary == null)
25             {
26                 FuncDictionary.Dictionary = CreateDictionary();
27             }
28 
29             if (!FuncDictionary.Dictionary.ContainsKey(type))
30             {
31                 return null;
32             }
33 
34             Delegate action = FuncDictionary.Dictionary[type];
35 
36             return action.DynamicInvoke(new object[] { arg });
37         }
38 
39         public static IDictionary<Type, Delegate> CreateDictionary()
40         {
41             var dictionary = new Dictionary<Type, Delegate>();
42 
43             dictionary.Add(typeof(string), new Func<string, string>(p => p));
44             dictionary.Add(typeof(decimal), new Func<string, decimal>(p => p.AsDecimal()));
45             dictionary.Add(typeof(DateTime), new Func<string, DateTime>(p => p.AsDateTime()));
46             dictionary.Add(typeof(float), new Func<string, float>(p => p.AsFloat()));
47             dictionary.Add(typeof(double), new Func<string, double>(p => p.AsDouble()));
48             dictionary.Add(typeof(int), new Func<string, int>(p => p.AsInt()));
49             dictionary.Add(typeof(byte), new Func<string, byte>(p => p.AsByte()));
50             dictionary.Add(typeof(sbyte), new Func<string, sbyte>(p => p.AsSbyte()));
51             dictionary.Add(typeof(short), new Func<string, short>(p => p.AsShort()));
52             dictionary.Add(typeof(ushort), new Func<string, ushort>(p => p.AsUshort()));
53             dictionary.Add(typeof(uint), new Func<string, uint>(p => p.AsUint()));
54             dictionary.Add(typeof(long), new Func<string, long>(p => p.AsLong()));
55             dictionary.Add(typeof(ulong), new Func<string, ulong>(p => p.AsUlong()));
56             dictionary.Add(typeof(char), new Func<string, char>(p => p.AsChar()));
57             dictionary.Add(typeof(bool), new Func<string, bool>(p => p.AsBool()));
58             dictionary.Add(typeof(Color), new Func<string, Color>(p => p.AsColor()));
59 
60             return dictionary;
61         }
62     }

 再看下XmlAttributeUtility类，该类主要包括转换和匹配操作。匹配主要为两种方案（主要逻辑为以下代码的72-183行）：

1、通过XmlReader顺序读取来设置实体的值，主要方法为public static IList<T> Parse<T>(XmlReader reader) where T : new()：

2、通过遍历XmlNodeList中的节点，依次遍历节点中的XmlAttribute设置实体的属性的值，主要方法为：public static IList<T> Parse<T>(XmlNodeList nodeList) where T : new()

  1         public static IList<T> Parse<T>(string inputUri, string parentXPath) where T : new()
  2         {
  3             if (!File.Exists(inputUri) || string.IsNullOrWhiteSpace(parentXPath))
  4             {
  5                 return new List<T>();
  6             }
  7 
  8             XmlDocument document = new XmlDocument();
  9             document.Load(inputUri);
 10 
 11             return Parse<T>(document, parentXPath);
 12         }
 13 
 14         public static IList<T> Parse<T>(XmlDocument document, string parentXPath) where T : new()
 15         {
 16             if (document == null || string.IsNullOrWhiteSpace(parentXPath))
 17             {
 18                 return new List<T>();
 19             }
 20 
 21             XmlNode parentNode = document.DocumentElement.SelectSingleNode(parentXPath);
 22 
 23             if (parentNode == null)
 24             {
 25                 return new List<T>();
 26             }
 27 
 28             return Parse<T>(parentNode);
 29         }
 30 
 31         public static IList<T> Parse<T>(XmlNode parentNode) where T : new()
 32         {
 33             if (parentNode == null || !parentNode.HasChildNodes)
 34             {
 35                 return new List<T>();
 36             }
 37 
 38             XmlNodeList nodeList = parentNode.ChildNodes;
 39 
 40             return Parse<T>(nodeList);
 41         }
 42 
 43         public static IList<T> Parse<T>(XmlNodeList nodeList) where T : new()
 44         {
 45             if (nodeList == null || nodeList.Count == 0)
 46             {
 47                 return new List<T>();
 48             }
 49 
 50             List<T> entities = new List<T>();
 51             AddEntities<T>(nodeList, entities);
 52 
 53             return entities;
 54         }
 55 
 56         public static IList<T> Parse<T>(string inputUri) where T : new()
 57         {
 58             if (!File.Exists(inputUri))
 59             {
 60                 return new List<T>();
 61             }
 62 
 63             XmlReaderSettings settings = new XmlReaderSettings();
 64             settings.IgnoreComments = true;
 65             settings.IgnoreWhitespace = true;
 66 
 67             XmlReader reader = XmlReader.Create(inputUri, settings);
 68 
 69             return Parse<T>(reader);
 70         }
 71 
 72         public static IList<T> Parse<T>(XmlReader reader) where T : new()
 73         {
 74             if (reader == null)
 75             {
 76                 return new List<T>();
 77             }
 78 
 79             reader.ReadStartElement();
 80             string className = GetClassName<T>();     
 81             List<PropertyInfo> properties = typeof(T).GetProperties().ToList();
 82             List<T> entities = new List<T>();
 83             T entity = new T();
 84 
 85             while (!reader.EOF)
 86             {
 87                 if (!string.Equals(reader.Name, className) || !reader.IsStartElement())
 88                 {
 89                     reader.Read();
 90                     continue;
 91                 }
 92 
 93                 entity = new T();
 94 
 95                 if (!reader.HasAttributes)
 96                 {
 97                     entities.Add(entity);
 98                     reader.Read();
 99                     continue;
100                 }
101 
102                 SetPropertyValue<T>(reader, properties, entity);
103                 entities.Add(entity);
104                 reader.Read();
105             }
106 
107             reader.Close();
108 
109             return entities;
110         }
152 
153         private static void AddEntities<T>(XmlNodeList nodeList,
154             List<T> entities) where T : new()
155         {
156             string className = GetClassName<T>();
157             List<PropertyInfo> properties = typeof(T).GetProperties().ToList();
158             T entity = new T();
159 
160             foreach (XmlNode xmlNode in nodeList)
161             {
162                 XmlElement element = xmlNode as XmlElement;
163                 if (element == null || !string.Equals(className, element.Name))
164                 {
165                     continue;
166                 }
167 
168                 entity = new T();
169                 if (!element.HasAttributes)
170                 {
171                     entities.Add(entity);
172                     continue;
173                 }
174 
175                 XmlAttributeCollection attributes = element.Attributes;
176                 foreach (XmlAttribute attribute in attributes)
177                 {
178                     SetPropertyValue<T>(properties, entity, attribute.Name, attribute.Value);
179                 }
180 
181                 entities.Add(entity);
182             }
183         }
184 
185         private static void SetPropertyValue<T>(XmlReader reader, 
186             List<PropertyInfo> properties, T entity) where T : new()
187         {
188             while (reader.MoveToNextAttribute())
189             {
190                 SetPropertyValue<T>(properties, entity, reader.Name, reader.Value);
191             }
192         }
193 
194         private static void SetPropertyValue<T>(List<PropertyInfo> properties,
195             T entity, string name, string value) where T : new()
196         {
197             foreach (var property in properties)
198             {
199                 if (!property.CanWrite)
200                 {
201                     continue;
202                 }
203 
204                 string propertyName = GetPropertyName(property);
205 
206                 if (string.Equals(name, propertyName))
207                 {
208                     FuncDictionary action = new FuncDictionary();
209                     object invokeResult = action.DynamicInvoke(property.PropertyType, value);
210 
211                     property.SetValue(entity, invokeResult, null);
212                 }
213             }
214         }

XmlAttributeUtility的转换操作相对来说比较简单，采用反射+LinqToXml转换操作就很简单了，主要实现方法为public static XElement Convert<T>(T entity) where T : new()，其他方法都是以该方法作为基础来进行操作。为什么用LinqToXml？主要原因是LinqToXml比Xml更方便，很多细节方面不需要考虑太多。代码如下：

 1         public static string ConvertToString<T>(List<T> entities) where T : new()
 2         {
 3             List<XElement> elements = Convert<T>(entities);
 4             if (elements == null || elements.Count == 0)
 5             {
 6                 return string.Empty;
 7             }
 8 
 9             StringBuilder builder = new StringBuilder();
10             elements.ForEach(p => builder.AppendLine(p.ToString()));
11 
12             return builder.ToString();
13         }
14 
15         public static List<XElement> Convert<T>(List<T> entities) where T : new()
16         {
17             if (entities == null || entities.Count == 0)
18             {
19                 return new List<XElement>();
20             }
21 
22             List<XElement> elements = new List<XElement>();
23             XElement element;
24 
25             foreach (var entity in entities)
26             {
27                 element = Convert<T>(entity);
28                 if (element == null)
29                 {
30                     continue;
31                 }
32 
33                 elements.Add(element);
34             }
35 
36             return elements;
37         }
38 
39         public static string ConvertToString<T>(T entity) where T : new()
40         {
41             XElement element = Convert<T>(entity);
42             return element == null ? string.Empty : element.ToString();
43         }
44 
45         public static XElement Convert<T>(T entity) where T : new()
46         {
47             if (entity == null)
48             {
49                 return null;
50             }
51 
52             string className = GetClassName<T>();
53             XElement element = new XElement(className);
54 
55             List<PropertyInfo> properties = typeof(T).GetProperties().ToList();
56             string propertyName = string.Empty;
57             object propertyValue = null;
58 
59             foreach (PropertyInfo property in properties)
60             {
61                 if (property.CanRead)
62                 {
63                     propertyName = GetPropertyName(property);
64                     propertyValue = property.GetValue(entity, null);
65                     if (property.PropertyType.Name == "Color")
66                     {
67                         propertyValue = ColorTranslator.ToHtml((Color)propertyValue);
68                     }
69                     element.SetAttributeValue(propertyName, propertyValue);
70                 }
71             }
72 
73             return element;
74         }

该类中还包括其他的一些操作，此处不再概述，详细参见源码。

四、单元测试

 FuncDictionary的单元测试必须涵盖所有类型的测试才能将代码覆盖率达到100%，此处只针对DateTime做正常测试、异常测试和空值测试（当然，对于其他类型的方法，可能还需要做脚本测试，SQL注入测试等，这三种类型的测试是最基本的测试），主要测试代码如下：

 1         [TestMethod()]
 2         public void DynamicInvokeTest()
 3         {
 4             FuncDictionary target = new FuncDictionary();
 5             Type type = typeof(DateTime);
 6             string arg = new DateTime(2011, 9, 5, 18, 18, 18).ToString();
 7 
 8             DateTime result = (DateTime)target.DynamicInvoke(type, arg);
 9             Assert.AreEqual(result.Year, 2011);
10             Assert.AreEqual(result.Month, 9);
11             Assert.AreEqual(result.Day, 5);
12             Assert.AreEqual(result.Hour, 18);
13             Assert.AreEqual(result.Minute, 18);
14             Assert.AreEqual(result.Second, 18);
15         }
16 
17         [TestMethod()]
18         public void DynamicInvokeWithNullOrEmptyArgsTest()
19         {
20             FuncDictionary target = new FuncDictionary();
21 
22             object result = target.DynamicInvoke(typeof(DateTime), null);
23             Assert.AreEqual((DateTime)result,DateTime.MinValue);
24 
25             result = target.DynamicInvoke(typeof(DateTime), string.Empty);
26             Assert.AreEqual((DateTime)result, DateTime.MinValue);
27 
28             result = target.DynamicInvoke(null, string.Empty);
29             Assert.AreEqual(result, null);
30         }
31 
32         [TestMethod()]
33         public void DynamicInvokeWithInvalidArgsTest()
34         {
35             FuncDictionary target = new FuncDictionary();
36 
37             object result = target.DynamicInvoke(typeof(DateTime), "w007");
38             Assert.AreEqual((DateTime)result, DateTime.MinValue);
39         }

其他代码的单元测试详细见源代码，也仅仅只做了些基本的测试，写测试比写代码费哥的时间，。

五、总结

以上的代码仅仅是当时想着怎么实现就怎么写的，完全是随意而写。仅供参考，实战没有多大意义，纯粹练习下灵感和手感，增强对技术的敏感性而已，纯属娱乐。对于

<Lexer LexerName="Name0" FontColor="#EE2BA9" CreatedTime="2011-10-25T21:16:18.7866084+08:00" Count="0" Exist="true" LineCommentPrefix="LineCommentPrefix0" StreamCommentPrefix="StreamCommentPrefix0" StreamCommentSuffix="StreamCommentSuffix0" />此类格式的Xml转换和匹配，以上的代码完全能够满足该需求。下一篇将讲述另外一种格式的匹配，不过也是通过反射和XmlReader来进行匹配的。

今天也是2011年最后一天，明天就是2012年了，在此恭祝大家2012元旦快乐，新一年，日子顺心多平安；新一年，祝福多多又暖暖；新一年，愿望件件都圆满；新一年，幸福快乐早实现；新一年，元旦祝福围身边；玛雅终结之年到了，所以，为了拯救人类，一定要快乐哦！

源码下载：XmlAttribute转换和匹配源代码