博客园_JasenKin

字典转换成实体列表

2012-05-31T15:23:00Z

。。。。。。。

递归算法与优化后的算法对比

2012-02-21T17:02:00Z

前段时间看了《【面试】——反应迟钝的递归》中的三个递归算法，斐波那契数列优化后的算法思路确实不错，但是后面2个数列用递归的话，个人感觉有点得不偿失。能不用递归的话，尽量不用，因为有些算法完全可以用数学来解决。因此，本文中将这三个数列的最终算法总结如下。

1、计算数组1,1,2,3,5,8,13...第30位的值

递归算法如下：

        public static int CalculateFibonacciSequence(int index)
        {
            if (index <= 0)
            {
                return 0;
            }

            if (index == 1 || index == 2)
            {
                return 1;
            }

            return CalculateFibonacciSequence(index - 1) + CalculateFibonacciSequence(index - 2);
        }

用递归算法来计算的话，有很多重复性的操作，采用数组相对来说，效率更高，最终算法如下：

        public static int CalculateFibonacciSequence(int index)
        {
            if (index <= 0)
            {
                return 0;
            }

            if (index == 1 || index == 2)
            {
                return 1;
            }

            int[] fibonacciArray = new int[index];
            fibonacciArray[0] = 1;
            fibonacciArray[1] = 1;

            for (int innerIndex = 2; innerIndex < fibonacciArray.Length; innerIndex++)
            {
                fibonacciArray[innerIndex] = fibonacciArray[innerIndex - 1] + fibonacciArray[innerIndex - 2];
            }

            return fibonacciArray[index - 1];
        }

对于斐波那契数列，通用公式为Fn=F(n-1)+F(n-2)（n>=2，n∈N*），直接循环计算一次就可以获得所需的值。

2、计算1+2+3+4+...+n的值

递归算法如下：

        public static int CalculateNumberSequenceCount(int index)
        {
            if (index <= 0)
            {
                return 0;
            }

            return CalculateNumberSequenceCount(index - 1) + index;
        }

当数字（index）很大时，用上面的递归算法肯定是有问题的，我们看下最终的算法，如下所示：

        public static int CalculateNumberSequenceCount(int index)
        {
            if (index <= 0)
            {
                return 0;
            }

            return index * (index + 1) / 2;
        }

对于1+2+3+4+...+n，完全是高中数学的等差数列求和的一个特例。1+2+3+4+......+n等于（首项+末项）*项数/2，所以结果为n(n+1)/2 。这个完全可以不用递归来进行计算，公式套用一下就解决了。

3、计算1-2+3-4+5-6+7+...+n的值

递归算法如下：

        public static int CalculateNumberSequence(int index)
        {
            if (index <= 0)
            {
                return 0;
            }

            return index % 2 == 0 ? CalculateNumberSequence(index - 1) - index : CalculateNumberSequence(index - 1) + index;
        }

对于1-2+3-4+5-6+7+...+n，可以分为2种情况，分别为：

（1）当n是偶数时，1-2+3-4+5-6+7+...+n=(1-2)+(3-4)+(5-6)+……+[(n-1)-n]

=-1×（n/2）

=-n/2

（2）当n是奇数时，1-2+3-4+5-6+7+...+n=(1-2)+(3-4)+(5-6)+……+[(n-2)-(n-1)]+n

=-1×(n-1)/2 +n

=(n+1)/2

因此，最终的算法如下：

        public static int CalculateCrossNumberSequence(int index)
        {
            if (index <= 0)
            {
                return 0;
            }

            return index % 2 == 0 ? -index / 2 : (index + 1) / 2;
        }

能够用数学解决的问题，尽量不要用递归来进行计算。当然，很多情况还是需要用递归的。这里并不是说递归算法不好，只能说具体问题采用最优方式来解决才是最终的方案，希望对各位有所帮助。

本文链接

Xml匹配为对象集合（两种不同的方式）

2012-02-19T03:38:00Z

一、前言

上一篇随笔主要将实体转换成相应的Xml或者Xml对象，未考虑到属性的Attribute特性，以后有时间再整理一下。本文中的Xml匹配涉及到类的特性和属性的特性，并且对该类的匹配进行了相应的优化，尽量将反射引起的性能问题降低最低（其实，对于对象数量不是很多的Xml匹配，性能是可以忽略不计的）。

二、类图设计

主要思路为：通过反射将与类名的节点匹配，然后匹配属性（属性特性名称或者属性名称）值，设计图如下所示：

类图中各个类的作用如下：

PropertyAttribute、ClassAttribute、StringExtension、FuncDictionary的作用详见XmlAttribute与实体的转换和匹配方案（附源码）。

AttributeUtility主要用于获取类名和属性名称。

ReflectionUtility主要用于获取类型的属性对象与属性对应的特性名称的字典，为匹配进行优化处理。

XmlParser主要用于匹配Xml为实体对象。

三、具体实现

3.1 ReflectionUtility

该类主要用于获取某个类型的特性名称和相应的属性对象的字典。返回的类型为Dictionary<string, PropertyInfo>，其中Key为属性的特性名称，而非属性名称，Vaule为对应的属性对象。如此设计，主要是方便后续的操作。

主要方法为：

public static Dictionary<string, PropertyInfo> GetPropertyMapperDictionary<T>() where T : new()，

public static Dictionary<string, PropertyInfo> GetPropertyMapperDictionary(Type type) ，代码如下：

1     public class ReflectionUtility
2     {
3         public static Dictionary<string, PropertyInfo> GetPropertyMapperDictionary<T>() where T : new()
4         {
5             return GetPropertyMapperDictionary(typeof(T));
6         }
7
8         public static Dictionary<string, PropertyInfo> GetPropertyMapperDictionary(Type type)
9         {
10             if (type == null)
11             {
12                 return null;
13             }
14
15             List<PropertyInfo> properties = type.GetProperties().ToList();
16             var nameMapperDic = new Dictionary<string, PropertyInfo>();
17             string propertyAttributeName = null;
18
19             foreach (PropertyInfo property in properties)
20             {
21                 propertyAttributeName = AttributeUtility.GetPropertyName(property);
22                 nameMapperDic.Add(propertyAttributeName, property);
23             }
24
25             return nameMapperDic;
26         }
27
28         public static IList<string> GetPropertyNames<T>() where T : new()
29         {
30             List<PropertyInfo> properties = typeof(T).GetProperties().ToList();
31             var propertyNames = new List<string>();
32
33             foreach (PropertyInfo property in properties)
34             {
35                 propertyNames.Add(AttributeUtility.GetPropertyName(property));
36             }
37
38             return propertyNames;
39         }
40     }

3.2 AttributeUtility

该类主要用于获取某个类型的类的特性名称和属性的特性名称。如果类的特性不存在，则返回类名。如果属性的特性名称不存在，则返回属性的名称。

主要方法为：

public static string GetClassName<T>() where T : new()，

public static string GetClassName(Type type) ，

public static string GetPropertyName(PropertyInfo property) ，代码如下：

1     public class AttributeUtility
2     {
3         public static string GetClassName<T>() where T : new()
4         {
5             return GetClassName(typeof(T));
6         }
7
8         public static string GetClassName(Type type)
9         {
10             if (type == null)
11             {
12                 return string.Empty;
13             }
14
15             string className = type.Name;
16             ClassAttribute[] attributes = type.GetCustomAttributes(
17                 typeof(ClassAttribute), false) as ClassAttribute[];
18
19             if (attributes != null && attributes.Length > 0)
20             {
21                 if (!string.IsNullOrWhiteSpace(attributes[0].Name))
22                 {
23                     className = attributes[0].Name;
24                 }
25             }
26
27             return className;
28         }
29
30         public static string GetPropertyName(PropertyInfo property)
31         {
32             if (property == null)
33             {
34                 return string.Empty;
35             }
36
37             string propertyName = property.Name;
38
39             PropertyAttribute[] attributes = property.GetCustomAttributes(typeof(PropertyAttribute),
40                 false) as PropertyAttribute[];
41
42             if (attributes != null && attributes.Length > 0)
43             {
44                 if (!string.IsNullOrWhiteSpace(attributes[0].Name))
45                 {
46                     propertyName = attributes[0].Name;
47                 }
48             }
49
50             return propertyName;
51         }
52     }

3.2 XmlParser

该类主要通过两种不同的方式匹配Xml为实体对象集合，一种直接通过XmlReader进行只进读取匹配，另外一种通过XElement进行相应的匹配。

主要方法为：

public static IList<T> Parse<T>(string xmlContent) where T : new()，

public static IList<T> Parse<T>(XDocument document) where T : new() ，

public static IList<T> Parse<T>(IEnumerable<XElement> elements) where T : new()，

public static IList<T> Parse<T>(XmlReader xmlReader) where T : new() ，代码如下：

  1     public class XmlParser
  2     {
  3         public static IList<T> Parse<T>(string xmlContent) where T : new()
  4         {
  5             try
  6             {
  7                 if (string.IsNullOrWhiteSpace(xmlContent))
  8                 {
  9                     return new List<T>();
10                 }
11
12                 using (StringReader reader = new StringReader(xmlContent))
13                 {
14                     return Parse<T>(XmlReader.Create(reader));
15                 }
16             }
17             catch
18             {
19                 return new List<T>();
20             }
21         }
22
23         public static IList<T> Parse<T>(XDocument document) where T : new()
24         {
25             if (document == null)
26             {
27                 return new List<T>();
28             }
29
30             string className = AttributeUtility.GetClassName<T>();
31             IEnumerable<XElement> elements = document.Root.Elements(className);
32
33             return Parse<T>(elements);
34         }
35
36         public static IList<T> Parse<T>(IEnumerable<XElement> elements) where T : new()
37         {
38             if (elements == null || elements.Count() == 0)
39             {
40                 return new List<T>();
41             }
42
43             try
44             {
45                 var propertyDic = ReflectionUtility.GetPropertyMapperDictionary<T>();
46                 List<T> entities = new List<T>();
47                 IEnumerable<XElement> innerElements = null;
48                 T entity = new T();
49
50                 foreach (XElement element in elements)
51                 {
52                     entity = new T();
53                     entities.Add(entity);
54                     innerElements = element.Elements();
55
56                     foreach (XElement innerElement in innerElements)
57                     {
58                         SetPropertyValue<T>(propertyDic, entity, innerElement.Name.ToString(), innerElement.Value);
59                     }
60                 }
61
62                 return entities;
63             }
64             catch
65             {
66                 return new List<T>();
67             }
68         }
69
70         public static IList<T> Parse<T>(XmlReader xmlReader) where T : new()
71         {
72             try
73             {
74                 if (xmlReader == null)
75                 {
76                     return new List<T>();
77                 }
78
79                 return ParseXmlReader<T>(xmlReader);
80             }
81             catch
82             {
83                 return new List<T>();
84             }
85         }
86
87         private static IList<T> ParseXmlReader<T>(XmlReader xmlReader) where T : new()
88         {
89             List<PropertyInfo> properties = new List<PropertyInfo>(typeof(T).GetProperties());
90             var propertyDic = ReflectionUtility.GetPropertyMapperDictionary<T>();
91             string className = AttributeUtility.GetClassName<T>();
92             IList<T> entities = new List<T>();
93             T entity = new T();
94             string lastElementName = null;
95
96             while (xmlReader.Read())
97             {
98                 switch (xmlReader.NodeType)
99                 {
100                     case XmlNodeType.Element:
101                         if (string.Equals(xmlReader.Name, className))
102                         {
103                             entity = new T();
104                             entities.Add(entity);
105                         }
106                         lastElementName = xmlReader.Name;
107                         break;
108                     case XmlNodeType.Text:
109                         SetPropertyValue<T>(propertyDic, entity, lastElementName, xmlReader.Value);
110                         break;
111                     default:
112                         break;
113                 }
114             }
115
116             return entities;
117         }
118
119         private static void SetPropertyValue<T>(Dictionary<string, PropertyInfo> propertyDic, T entity, string lastElementName, string value) where T : new()
120         {
121             if (!string.IsNullOrWhiteSpace(lastElementName) && propertyDic.ContainsKey(lastElementName))
122             {
123                 PropertyInfo currentProperty = propertyDic[lastElementName];
124                 if (currentProperty != null && currentProperty.CanWrite)
125                 {
126                     object invokeResult = new FuncDictionary().DynamicInvoke(currentProperty.PropertyType, value);
127                     currentProperty.SetValue(entity, invokeResult, null);
128                 }
129             }
130         }
131     }

以上两种不同的方式匹配Xml，都是通过var propertyDic = ReflectionUtility.GetPropertyMapperDictionary<T>();来对反射所引起的性能进行了相关的优化。对于多个实体的匹配，只需要执行一次映射获取到属性特性的名称与对应属性的字典，其后的匹配以该字典来进行操作。

四、总结

与上一篇随笔将对象集合转换为Xml恰恰相反，对于如下类似格式的Xml：

<MapperInfoItem>
  <DefaultName>MapperInfoItemIndex0</DefaultName>
  <CreatedTime>2012/1/6 19:24:34</CreatedTime>
  <IsActive>True</IsActive>
  <DefaultValue>10</DefaultValue>
  <Percent>27</Percent>
  <TargetUrl>www.codeplex.com?Id=0</TargetUrl>
</MapperInfoItem>

本文中以上的代码完全能够对其进行相应的匹配。只不过上一篇随笔中未对类的特性名称和属性的特性名称进行考虑罢了，以后有时间再贴上改进后的代码。

本文链接

实体集合和实体转换成相应的string、XDocument、XElement、XDocument

2012-02-19T01:46:00Z

一、前言

上篇随笔主要是针对于Xml的特性Attribute与实体之间的匹配与转换。该篇随笔主要内容为将对象转换成相应的Xml以及XElement。这2篇随笔以不同的方式对Xml进行转换与匹配，每种匹配都采用不同的角度进行操作。本文主要为对象实体的转换，下篇侧重于Xml的匹配。

二、Xml转换

2.1 实体集合转换Xml

实体集合转换Xml的方法为：public static string ToXml<T>(IList<T> entities, string rootName = "") where T : new()，通过传入的实体集合对象和Xml根名称，可以转换成相应的Xml，代码如下：

1         public static string ToXml<T>(IList<T> entities, string rootName = "") where T : new()
2         {
3             if (entities == null || entities.Count == 0)
4             {
5                 return string.Empty;
6             }
7
8             StringBuilder builder = new StringBuilder();
9             builder.AppendLine(XmlResource.XmlHeader);
10
11             XElement element = ToXElement<T>(entities, rootName);
12             builder.Append(element.ToString());
13
14             return builder.ToString();
15         }

针对于实体集合的转换，转换后的结果如下：

1 <?xml version="1.0" encoding="utf-8" ?>
2 <MapperInfoSet>
3   <MapperInfo>
4     <Name>MapperInfoIndex0</Name>
5     <CreatedTime>2012-02-19T08:54:44.9411601+08:00</CreatedTime>
6     <IsActive>true</IsActive>
7     <Value>0</Value>
8     <Percent>50</Percent>
9     <TargetUrl>www.codeplex.com?Id=0</TargetUrl>
10   </MapperInfo>
11   <MapperInfo>
12     <Name>MapperInfoIndex1</Name>
13     <CreatedTime>2012-02-19T08:54:44.9421602+08:00</CreatedTime>
14     <IsActive>false</IsActive>
15     <Value>1</Value>
16     <Percent>50</Percent>
17     <TargetUrl>www.codeplex.com?Id=1</TargetUrl>
18   </MapperInfo>
19 </MapperInfoSet>

2.2 实体转换Xml

实体转换Xml的方法为：public static string ToXml<T>(T entity) where T : new()，通过传入的实体，可以转换成相应的Xml，代码如下：

1         public static string ToXml<T>(T entity) where T : new()
2         {
3             if (entity == null)
4             {
5                 return string.Empty;
6             }
7
8             XElement element = ToXElement<T>(entity);
9
10             return element.ToString();
11         }

针对于单个实体的转换，转换后的结果如下：

1 <MapperInfo>
2   <Name>MapperInfoIndex0</Name>
3   <CreatedTime>2012-02-19T08:59:17.1387289+08:00</CreatedTime>
4   <IsActive>true</IsActive>
5   <Value>0</Value>
6   <Percent>50</Percent>
7   <TargetUrl>www.codeplex.com?Id=0</TargetUrl>
8 </MapperInfo>

2.3 实体集合转换XElement

实体转换XElement的方法为：public static XElement ToXElement<T>(IList<T> entities, string rootName = "") where T : new()，通过传入的实体集合对象和Xml根名称，可以转换成相应的XElement，代码如下：

1         public static XElement ToXElement<T>(IList<T> entities, string rootName = "") where T : new()
2         {
3             if (entities == null || entities.Count == 0)
4             {
5                 return null;
6             }
7
8             if (string.IsNullOrWhiteSpace(rootName))
9             {
10                 rootName = typeof(T).Name + XmlResource.XmlRootNameSuffix;
11             }
12
13             XElement element = new XElement(rootName);
14
15             foreach (T entity in entities)
16             {
17                 element.Add(ToXElement<T>(entity));
18             }
19
20             return element;
21         }

2.4 实体集合转换XmlDocument

实体转换XmlDocument的方法为：public static XElement ToXmlDocument<T>(IList<T> entities, string rootName = "") where T : new()，通过传入的实体集合对象和Xml根名称，可以转换成相应的XmlDocument，代码如下：

1         public static XmlDocument ToXmlDocument<T>(IList<T> entities, string rootName = "") where T : new()
2         {
3             if (entities == null || entities.Count == 0)
4             {
5                 return null;
6             }
7
8             XmlDocument xmlDocument = new XmlDocument();
9             xmlDocument.LoadXml(ToXml<T>(entities, rootName));
10
11             return xmlDocument;
12         }

2.5 实体转换XElement

实体转换XElement的方法为：public static string ToXElement<T>(T entity) where T : new()，通过传入的实体，可以转换成相应的XElement，代码如下：

1         public static XElement ToXElement<T>(T entity) where T : new()
2         {
3             if (entity == null)
4             {
5                 return null;
6             }
7
8             XElement element = new XElement(typeof(T).Name);
9             PropertyInfo[] properties = typeof(T).GetProperties();
10             XElement innerElement = null;
11             object propertyValue = null;
12
13             foreach (PropertyInfo property in properties)
14             {
15                 propertyValue = property.GetValue(entity, null);
16                 innerElement = new XElement(property.Name, propertyValue);
17                 element.Add(innerElement);
18             }
19
20             return element;
21         }

2.6 实体集合转换XDocument

实体转换XDocument的方法为：public static XDocument ToXDocument<T>(IList<T> entities, string rootName = "") where T : new()，通过传入的实体集合对象和Xml根名称，可以转换成相应的XDocument，代码如下：

1         public static XDocument ToXDocument<T>(IList<T> entities, string rootName = "") where T : new()
2         {
3             if (entities == null || entities.Count == 0)
4             {
5                 return null;
6             }
7
8             return  XDocument.Parse(ToXml<T>(entities, rootName));
9         }

三、总结

以上的代码很少，主要通过重构来使代码简化。当然，将实体集合和实体转换为相应的string、XDocument、XElement、XDocument是非常简单的。单元测试的代码就不贴了，占地方。下篇随笔主要是如何将本文中转换的Xml进行匹配，本文所有的代码如下：

    public class SimpleXmlConverter
    {
        public static string ToXml<T>(IList<T> entities, string rootName = "") where T : new()
        {
            if (entities == null || entities.Count == 0)
            {
                return string.Empty;
            }

            StringBuilder builder = new StringBuilder();
            builder.AppendLine(XmlResource.XmlHeader);

            XElement element = ToXElement<T>(entities, rootName);
            builder.Append(element.ToString());

            return builder.ToString();
        }

        public static XmlDocument ToXmlDocument<T>(IList<T> entities, string rootName = "") where T : new()
        {
            if (entities == null || entities.Count == 0)
            {
                return null;
            }

            XmlDocument xmlDocument = new XmlDocument();
            xmlDocument.LoadXml(ToXml<T>(entities, rootName));

            return xmlDocument;
        }

        public static XDocument ToXDocument<T>(IList<T> entities, string rootName = "") where T : new()
        {
            if (entities == null || entities.Count == 0)
            {
                return null;
            }

            return  XDocument.Parse(ToXml<T>(entities, rootName));
        }

        public static XElement ToXElement<T>(IList<T> entities, string rootName = "") where T : new()
        {
            if (entities == null || entities.Count == 0)
            {
                return null;
            }

            if (string.IsNullOrWhiteSpace(rootName))
            {
                rootName = typeof(T).Name + XmlResource.XmlRootNameSuffix;
            }

            XElement element = new XElement(rootName);

            foreach (T entity in entities)
            {
                element.Add(ToXElement<T>(entity));
            }

            return element;
        }

        public static string ToXml<T>(T entity) where T : new()
        {
            if (entity == null)
            {
                return string.Empty;
            }

            XElement element = ToXElement<T>(entity);

            return element.ToString();
        }

        public static XElement ToXElement<T>(T entity) where T : new()
        {
            if (entity == null)
            {
                return null;
            }

            XElement element = new XElement(typeof(T).Name);
            PropertyInfo[] properties = typeof(T).GetProperties();
            XElement innerElement = null;
            object propertyValue = null;

            foreach (PropertyInfo property in properties)
            {
                propertyValue = property.GetValue(entity, null);
                innerElement = new XElement(property.Name, propertyValue);
                element.Add(innerElement);
            }

            return element;
        }

        public static XElement ToXElement(Type type)
        {
            if (type == null)
            {
                return null;
            }

            XElement element = new XElement(type.Name);
            PropertyInfo[] properties = type.GetProperties();
            XElement innerElement = null;

            foreach (PropertyInfo property in properties)
            {
                innerElement = new XElement(property.Name, null);
                element.Add(innerElement);
            }

            return element;
        }
    }

本文链接

kawei

2012-01-31T10:20:00Z

kawei

本文链接

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

2011-12-30T17:14:00Z

一、前言

可扩展标记语言 (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转换和匹配源代码

本文链接

lINE

2011-11-07T23:31:00Z

/Files/jasenkin/CircularDependencyTool.zip

本文链接

IronRuby实现对Ruby类相关信息的树结构显示（C#）

2011-10-24T15:00:00Z

一、前言

IronRuby是.NET下的一个Ruby实现，此外还有Ruby.net这一开源项目，二者的主要区别是IronRuby利用了Microsoft最新推出的DLR，而Ruby.net则是完全利用原有的CLR实现的。IronRuby入门可参阅http://msdn.microsoft.com/zh-cn/magazine/dd434651.aspx。关于IronRuby的一些基本操作，本文不会涉及，本文仅仅是IronRuby对Ruby操作的一个具体实例。其中包括对所有Ruby类的类名，方法名以及参数列表的获取与显示相关的树结构。究其原因采用IronRuby来进行操作，主要是因为通过Ruby的反射可以获取到Ruby方法名列表，但是获取不到方法的参数列表与参数名称。此文仅供参考，因为本人也对IronRuby接触不是很久，基本上是摸索出来的，难免会有错误的地方。

二、类图设计

相关类图设计如下，其中RubyScriptEngine主要负责通过IronRuby来获取和构造相关的类名、方法名与参数列表以及之间的相关关系。TreeDrawer主要负责设计类名、方法名与参数列表相对应的树形结构图。

三、详细设计

（1）RubyScriptEngine主要负责通过IronRuby来获取和构造相关的类名、方法名与参数列表以及之间的相关关系。RubyScriptEngine将Ruby文件进行加载，然后动态获取文件中包含的类、方法与方法参数列表。

具体代码如下：

  1     public static class RubyScriptEngine
  2     {
  3         private static readonly ScriptEngine engine = null;
  4
  5         static RubyScriptEngine()
  6         {
  7             engine = Ruby.CreateEngine();
  8         }
  9
10         public static bool InitRelativeFiles(string directory)
11         {
12             if (!Directory.Exists(directory))
13             {
14                 return false;
15             }
16
17             string[] files = Directory.GetFiles(directory);
18             for (int index = 0; index < files.Length; index++)
19             {
20                 InitRelativeFile(files[index]);
21             }
22
23             return true;
24         }
25
26         public static bool InitRelativeFile(string fileName)
27         {
28             if (!File.Exists(fileName))
29             {
30                 return false;
31             }
32
33             try
34             {
35                 FileInfo fileInfo = new FileInfo(fileName);
36                 if (string.Equals(fileInfo.Extension, ".rb", StringComparison.CurrentCultureIgnoreCase))
37                 {
38                     engine.ExecuteFile(fileName);
39                 }
40             }
41             catch
42             {
43                 return false;
44             }
45
46             return true;
47         }
48
49         public static IList<string> GetClassNames()
50         {
51            return  engine.Runtime.Globals.GetVariableNames().ToList();
52         }
53
54         public static IList<ClassItem> GetClassesInfos()
55         {
56             IList<string> names = GetClassNames();
57             IList<ClassItem> items = new List<ClassItem>();
58             foreach (string name in names)
59             {
60                 items.Add(GetClassInfo(name));
61             }
62
63             return items;
64         }
65
66         public static ClassItem GetClassInfo(string className, params object[] parameters)
67         {
68             RubyClass rubyClass = engine.Runtime.Globals.GetVariable(className);
69             dynamic instance = engine.Operations.CreateInstance(rubyClass, parameters);
70             ClassItem classItem = new ClassItem(className);
71
72             IList<string> memberNames = engine.Operations.GetMemberNames(instance);
73
74             MethodItem methodItem = null;
75             ParameterItem parameterItem = null;
76             foreach (string memberName in memberNames)
77             {
78                 RubyMethodInfo methodInfo = rubyClass.GetMethod(memberName) as RubyMethodInfo;
79
80                 if (methodInfo == null)
81                 {
82                     continue;
83                 }
84
85                 methodItem = new MethodItem(memberName,className);
86
87                 RubyArray parameterArray = methodInfo.GetRubyParameterArray();
88                 SimpleAssignmentExpression[] expressions = methodInfo.Parameters.Optional;
89
90                 for (int index = 0; index < parameterArray.Count; index++)
91                 {
92                     RubyArray vas = parameterArray[index] as RubyArray;
93                     string type = vas[0].ToString();
94                     string name = vas[1].ToString();
95                     parameterItem = new ParameterItem(name);
96                     if (type == "rest")
97                     {
98                         parameterItem.DefaultName = "*" + name;
99                         parameterItem.Description = RubyResource.ArrayParamDesc;
100                     }
101                     else if (type == "opt")
102                     {
103                         for (int eindex = 0; eindex < expressions.Length; eindex++)
104                         {
105                             SimpleAssignmentExpression ex = expressions[eindex];
106                             Variable variable = ex.Left as Variable;
107                             if (!string.Equals(variable.Name, name))
108                             {
109                                 continue;
110                             }
111
112                             Literal literal = ex.Right as Literal;
113                             parameterItem.DefaultName = name;
114                             parameterItem.DefaultValue = literal.Value;
115                             parameterItem.Description = RubyResource.DefaultParamDesc;
116                         }
117                     }
118                     else if (type == "block")
119                     {
120                         parameterItem.DefaultName = "&" + name;
121                         parameterItem.Description = RubyResource.BlockParamDesc;
122                     }
123                     else
124                     {
125                         parameterItem.DefaultName = name;
126                     }
127                     methodItem.Parameters.Add(parameterItem);
128                 }
129                 classItem.Methods.Add(methodItem);
130             }
131
132             return classItem;
133         }
134     }

其中相关方法如下：

public static bool InitRelativeFiles(string directory) 根据目录加载目录下的Ruby文件

public static bool InitRelativeFile(string fileName) 根据文件名加载该Ruby文件

public static IList<string> GetClassNames() 获取所有的类名

public static IList<ClassItem> GetClassesInfos() 获取所有类的信息

public static ClassItem GetClassInfo(string className, params object[] parameters) 根据类名和类的构造函数参数获取对应的类信息

类的信息显示效果如下（左侧显示类的信息，右侧编辑器显示类的基本结构）：

（2）TreeDrawer主要用于绘制类的树结构，根据不同的类结构显示不同的效果。这里是用Winform来显示的，本来打算用Silverlight来实现，但是由于时间关系，将就着这样算了。当然，Silverlight显示的效果比Winform强多了，而且，本人Silverlight水平比Winform熟练很多（以前项目中用Silverlight动态绘制相关图形，因此比较熟悉）....

TreeDrawer的主要方法为以下2个：

1         public Bitmap CreateImage(ClassItem classItem, Font font)
2         {
3             if (classItem == null || font == null)
4             {
5                 return null;
6             }
7
8             ClassBlock classBlock = CreateCurrentClassBlock(classItem);
9             AddLinesAndBlockTexts(classBlock, font);
10
11             Bitmap bitmap = new Bitmap(3 * BLOCK_WIDTH + 2 * BLOCK_INNER_WIDTH, this.Height);
12             Graphics graphics = Graphics.FromImage(bitmap);
13             graphics.Clear(Color.White);
14             Pen ellipsePen = new Pen(Color.Blue, 2);
15
16             foreach (Line line in this.Lines)
17             {
18                 graphics.DrawLine(ellipsePen, line.X1, line.Y1, line.X2, line.Y2);
19                 if (line.HasArrow)
20                 {
21                     PointF[] points = CreateArrowPoints(new PointF(line.X1, line.Y1),
22                         new PointF(line.X2, line.Y2), ARROW_LENGTH, RELATIVE_VALUE);
23                     DrawArrowHead(graphics, points);
24                 }
25             }
26
27             foreach (BlockText content in this.Contents)
28             {
29                 graphics.DrawString(content.Content, font, Brushes.Black, content.StartX, content.StartY);
30             }
31
32             return bitmap;
33         }
34
35         private ClassBlock CreateCurrentClassBlock(ClassItem classItem)
36         {
37             int originalParamY = 0;
38             int lastParamY = 0;
39             int currentParamY = 0;
40             int currentMethodY = 0;
41             int startMethodX = BLOCK_WIDTH + BLOCK_INNER_WIDTH;
42             int startParamX = 2 * BLOCK_WIDTH + 2 * BLOCK_INNER_WIDTH;
43
44             List<MethodBlock> methodBlocks = new List<MethodBlock>();
45             foreach (MethodItem methodItem in classItem.Methods)
46             {
47                 int paramsCount = methodItem.Parameters.Count;
48                 if (paramsCount > 0)
49                 {
50                     lastParamY += paramsCount * (BLOCK_HEIGHT + BLOCK_INNER_HEGIHT);
51                 }
52                 else
53                 {
54                     lastParamY += (BLOCK_HEIGHT + BLOCK_INNER_HEGIHT);
55                     currentParamY += (BLOCK_HEIGHT + BLOCK_INNER_HEGIHT);
56                 }
57
58                 currentMethodY = ((lastParamY - BLOCK_INNER_HEGIHT - originalParamY) / 2 + originalParamY - (BLOCK_HEIGHT / 2));
59                 originalParamY = lastParamY;
60
61                 MethodBlock methodBlock = new MethodBlock(new Point(startMethodX, currentMethodY), BLOCK_WIDTH, BLOCK_HEIGHT);
62                 methodBlock.Content = methodItem.Name;
63                 methodBlocks.Add(methodBlock);
64                 foreach (ParameterItem parameterItem in methodItem.Parameters)
65                 {
66                     ParameterBlock parameterBlock = new ParameterBlock(new Point(startParamX, currentParamY), BLOCK_WIDTH, BLOCK_HEIGHT);
67                     parameterBlock.Content = parameterItem.DefaultName;
68                     methodBlock.ParameterBlocks.Add(parameterBlock);
69                     currentParamY += (BLOCK_HEIGHT + BLOCK_INNER_HEGIHT);
70                 }
71             }
72
73             if (lastParamY > 0)
74             {
75                 lastParamY -= BLOCK_INNER_HEGIHT;
76             }
77             else
78             {
79                 lastParamY = BLOCK_HEIGHT;
80             }
81
82             this.Height = lastParamY;
83
84             Point classStartPoint = new Point(0, 0);
85             if (classItem.Methods.Count > 1)
86             {
87                 int y = (methodBlocks.Last().LeftBottomPoint.Y - methodBlocks.First().LeftBottomPoint.Y) / 2;
88                 classStartPoint = new Point(0, y);
89             }
90
91             ClassBlock classBlock = new ClassBlock(classStartPoint, BLOCK_WIDTH, BLOCK_HEIGHT);
92             classBlock.Content = classItem.Name;
93             foreach (MethodBlock methodBlock in methodBlocks)
94             {
95                 classBlock.MethodBlocks.Add(methodBlock);
96             }
97
98             return classBlock;
99         }

public Bitmap CreateImage(ClassItem classItem, Font font) 主要负责绘制Bitmap图片

private ClassBlock CreateCurrentClassBlock(ClassItem classItem) 主要负责将ClassItem（类信息形式）转换成ClassBlock（坐标形式），并负责计算相应的坐标

类的树结构显示效果如下：

当然，还可以定义其他格式的类，显示的效果根据类的不同绘制相应的树结构。其中，TreeDrawer中比较简单的算法会自动设置合理的坐标，以生成相应的树结构坐标。本处一切以简单进行处理，不然的话，参数设置是比较多的。

四、总结

IronRuby是.NET下的一个Ruby实现，对于实现单个类的操作来说，用.NET 4.0中的Dynamic更加方便与美观，如调用PersonClass类的nonArgsMethod方法即可写成如下格式：

dynamic globals= engine.Runtime.Globals;
dynamic apple = globals.PersonClass.@new();  //构造实例
apple.nonArgsMethod();    //调用方法

本文中采用如下代码进行调用，主要是为了通用性处理。通过类名称以及构造函数的参数来动态获取类的信息。

RubyClass rubyClass = engine.Runtime.Globals.GetVariable(className);
dynamic instance = engine.Operations.CreateInstance(rubyClass, parameters);
ClassItem classItem = new ClassItem(className);
IList<string> memberNames = engine.Operations.GetMemberNames(instance);

源代码下载地址：IronRuby Ruby类树结构源码

本文链接

Winform ListView虚拟模式

2011-08-21T16:00:00Z

一、前言

虚拟模式在许多情况下都很有用。如果必须从已存在于内存中的非常大的集合填充一个 ListView 对象，则为每项创建一个 ListViewItem 对象会很浪费。在虚拟模式下，从缓冲之中获取所需的数据进行加载，性能会有很大提高。在其他情况下，可能需要经常重新计算 ListViewItem 对象的值，对整个集合进行此操作将产生不可接受的性能。

如下为虚拟模式的一个应用示例（仿VS2010错误列表），截图如下:

二、虚拟模式相关注意点

1、设置一个缓存属性，来保存需要加载的数据:

        protected List<ListViewItem> CurrentCacheItemsSource
        {
            get;
            private set;
        }

2、通过虚拟模式来加载数据，如下:

        private void LoadListViewItems(List<ListViewItem> items)
        {
            listView.Items.Clear();
            if (items == null)
            {
                stripStatusInfo.Text = "当前总共记录数为：0";
                return;
            }

            listView.GridLines = true;
            listView.FullRowSelect = true;
            listView.View = View.Details;
            listView.Scrollable = true;
            listView.MultiSelect = false;
            listView.HeaderStyle = ColumnHeaderStyle.Clickable;
            listView.Visible = true;

            listView.VirtualListSize = items.Count;
            listView.VirtualMode = true;
            listView.RetrieveVirtualItem += new RetrieveVirtualItemEventHandler(listView_RetrieveVirtualItem);

            stripStatusInfo.Text = "当前总共记录数为：" + items.Count;
        }

listView.VirtualMode = true;//设置虚拟模式

listView.VirtualListSize = items.Count;//设置虚拟列表容量大小

listView.RetrieveVirtualItem += new RetrieveVirtualItemEventHandler(listView_RetrieveVirtualItem);//绑定虚拟操作

3、在RetrieveVirtualItem方法中加载相关的数据：

       void listView_RetrieveVirtualItem(object sender, RetrieveVirtualItemEventArgs e)
        {
            if (this.CurrentCacheItemsSource == null || this.CurrentCacheItemsSource.Count == 0)
            {
                return;
            }

            e.Item = this.CurrentCacheItemsSource[e.ItemIndex];
            if (e.ItemIndex == this.CurrentCacheItemsSource.Count)
            {
                this.CurrentCacheItemsSource = null ;
            }
        }

需要注意及时释放掉所需要的缓存数据，如下：

if (e.ItemIndex == this.CurrentCacheItemsSource.Count)
{
this.CurrentCacheItemsSource = null ;
}

当e.ItemIndex 的值与缓存中的集合大小相等时，设置缓存为NULL（对象根引用设置为NULL，内存中的对象不再有根引用，所需的内存将由GC第二次回收时释放，相关内容请查看CLR GC）。

三、总结

当数据为几万条记录时，加载ListView速度非常快，不会造成任何影响，页面显示正常。目前，测试30W条简单的记录，性能还是可以接受的。当然，对于大数据量而言（50W条记录以上），分页才是最佳方式。其次，需要注意的是，对缓存数据需要及时清空，避免不必要的性能损失。

源代码下载：ListView虚拟模式源码

本文链接

C#插件开发简单模型

2011-07-15T05:29:00Z

一、前言

插件模型指应用程序由一些动态的独立模块构成，每个模块均具有一个或多个服务，并满足一定的插件协议，能够借助主程序实现主程序－插件，插件－插件之间的通讯。它定义了一套公共的接口，通过接口与插件进行通信，主要是通过反射来获取相关的属性和方法，然后再执行指定的操作。其实，它也可以理解为定义一套通用的解决方案，通过反射来获取相应的程序集的相关类型，然后执行这些指定类型的相关操作。它是一种即插即用的方案，更新及维护简便。

本文仅仅是描述插件开发的大体模型，设计比较简单，主要的步骤如下：

（1）、定义公共的接口以及抽象类。

（2）、定义和实现相关组件。

（3）、实现通用程序集反射操作类。

其中，公共的接口和抽象类定义在组件Jasen.Framework.Core中，该组件中提供通用程序集反射操作类AssemblyUtility；具体实现的相关组件为Jasen.Framework.Oracle、Jasen.Framework.Access和Jasen.Framework.SqlServer，它们都实现了Jasen.Framework.Core中的公共接口。客户端可以根据实际情况来进行相应的操作。相关组件图如下：

二、公共接口和抽象类的定义以及相关组件的定义和实现

首先，定义公共的接口以及抽象类，如下类图所示，定义一个公共的接口IDataTable，定义一个抽象类DataTable，这些公共的类型放置在最顶端的程序集中。而其他组件将分别重新创建，实现相对应的功能，如SqlServerDataTable、OracleDataTable和AccessDataTable实现各自的功能。注意：Assembly.LoadFile(file)动态加载程序集时，该程序集在当前的运行环境中必须不存在的，否则可能会出现意想不到的数据异常，因此相关组件的实现必须是独立的（仅仅是实现公共的接口）。

三、通用程序集反射操作类的实现

下面的AssemblyUtility主要是对程序集操作的通用类，可以根据指定目录以及文件列表动态获取相应的程序集。同时，也可以通过目录，文件以及程序集获取相关的类型集合和对象集合。其中需要注意的是，实现的子类必须提供默认构造函数。客户端可以通过该类获取相应的类型和对象集合，然后再执行相应的操作。这些操作都是通过动态加载程序集来实现的，代码如下所示：

    public static class AssemblyUtility
    {
        public static IEnumerable<Type> GetImplementdTypesByDirectory<T>(string baseDirectory)
        {
           IList<Assembly> assemblies= GetAssemblies(baseDirectory);
           List<Type> types = new List<Type>();
           foreach (Assembly assembly in assemblies)
           {
               types.AddRange(GetImplementdTypes<T>(assembly));
           }

           return types;
        }

        public static IEnumerable<Type> GetImplementdTypes<T>(string assemblyFile)
        {
            if (!File.Exists(assemblyFile))
            {
                return null;
            }
            try
            {
                return GetImplementdTypes<T>(Assembly.LoadFile(assemblyFile));
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        public static IEnumerable<Type> GetImplementdTypes<T>(Assembly assembly)
        {
            if (assembly == null)
            {
                return null;
            }

            return assembly.GetExportedTypes().Where(p =>
               p.IsSubclassOf(typeof(T)) && (!p.IsAbstract) && (!p.IsInterface));
        }

        public static IList<T> GetImplementedObjectsByDirectory<T>(string baseDirectory)
        {
            IList<Assembly> assemblies = GetAssemblies(baseDirectory);
            List<T> entities = new List<T>();
            foreach (Assembly assembly in assemblies)
            {
                entities.AddRange(GetImplementedObjects<T>(assembly));
            }

            return entities;
        }

        public static IList<T> GetImplementedObjects<T>(string assemblyFile)
        {
            if (!File.Exists(assemblyFile))
            {
                return null;
            }
            try
            {
                return GetImplementedObjects<T>(Assembly.LoadFile(assemblyFile));
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        public static IList<T> GetImplementedObjects<T>(Assembly assembly)
        {
            if (assembly == null)
            {
                return null;
            }

            IEnumerable<Type> types = GetImplementdTypes<T>(assembly);
            var result = new List<T>();

            foreach (Type type in types)
            {
                ConstructorInfo constructor = type.GetConstructor(new Type[0]);
                if (constructor == null)
                {
                    continue;
                }

                object instance = Activator.CreateInstance(type);
                if (instance is T)
                {
                    result.Add((T)instance);
                }
            }

            return result;
        }

        public static IList<Assembly> GetAssemblies(string baseDirectory)
        {
            if (!Directory.Exists(baseDirectory))
            {
                return new List<Assembly>();
            }

            string[] files = Directory.GetFiles(baseDirectory, "*.dll");

            return GetAssemblies(files);
        }

        public static IList<Assembly> GetAssemblies(string[] assemblyFiles)
        {
            IList<Assembly> assemblies = new List<Assembly>();
            try
            {
                foreach (string file in assemblyFiles)
                {
                    if (!File.Exists(file)||(!file.EndsWith(".dll",StringComparison.InvariantCultureIgnoreCase)))
                    {
                        continue;
                    }
                    assemblies.Add(Assembly.LoadFile(file));
                }
            }
            catch (Exception ex)
            {
                return new List<Assembly>();
            }

            return assemblies;
        }
    }

public static IEnumerable<Type> GetImplementdTypesByDirectory<T>(string baseDirectory)
public static IEnumerable<Type> GetImplementdTypes<T>(string assemblyFile)
public static IList<T> GetImplementedObjects<T>(Assembly assembly)

以上3个方法根据不同的参数（目录、地址、程序集）来动态获取程序集中的特定类型集合，这些类型为类型T的类或者子类（非抽象类和接口）。

public static IList<T> GetImplementedObjectsByDirectory<T>(string baseDirectory)
public static IList<T> GetImplementedObjects<T>(string assemblyFile)
public static IList<T> GetImplementedObjects<T>(Assembly assembly)
而以上3个方法根据不同的参数（目录、地址、程序集）来动态获取程序集中的特定对象集合，这些对象为类型T的类或者子类（非抽象类和接口）的实例。当组件中子类存在有参构造函数时，必须实现默认构造函数。从如下代码可以看出：如果默认构造函数不存在，将不会添加该对象实例。

                ConstructorInfo constructor = type.GetConstructor(new Type[0]);
                if (constructor == null)
                {
                    continue;
                }

                object instance = Activator.CreateInstance(type);
                if (instance is T)
                {
                    result.Add((T)instance);
                }

四、通用程序集反射操作类的单元测试

AssemblyUtility类主要的单元测试如下，仅验证了正确的情况，代码如下：

    public class AssemblyUtilityTest
    {
        [TestMethod()]
        public void GetAssembliesTest()
        {
            string assemblyPath = AppDomain.CurrentDomain.BaseDirectory+"\\Files\\";
            IList<Assembly> result = AssemblyUtility.GetAssemblies(assemblyPath);

            Assert.IsNotNull(result);
            Assert.AreEqual(3, result.Count);
        }

        [TestMethod()]
        public void GetAssembliesByFilesTest()
        {
            string[] assemblyFiles = new string[] { AppDomain.CurrentDomain.BaseDirectory + "\\Jasen.Framework.Core.dll",
                      AppDomain.CurrentDomain.BaseDirectory + "\\Jasen.Framework.Core.Test.dll",
                      "www",
                      "ww.dll"};
            IList<Assembly> result = AssemblyUtility.GetAssemblies(assemblyFiles);

            Assert.IsNotNull(result);
            Assert.AreEqual(2, result.Count);
        }

        [TestMethod()]
        public void GetImplementedObjectsByDirectoryTest()
        {
            string assemblyDir = AppDomain.CurrentDomain.BaseDirectory + "\\Files\\";
            IList<DataTable> result = AssemblyUtility.GetImplementedObjectsByDirectory<DataTable>(assemblyDir);
            Assert.IsNotNull(result);
            Assert.AreEqual(3, result.Count);
        }

        [TestMethod()]
        public void GetImplementedObjectsTest()
        {
            string assemblyFile =AppDomain.CurrentDomain.BaseDirectory + "\\Files\\Jasen.Framework.Oracle.dll";
            IList<DataTable> result = AssemblyUtility.GetImplementedObjects<DataTable>(assemblyFile);
            Assert.IsNotNull(result);
            Assert.AreEqual(1, result.Count);
        }

        [TestMethod()]
        public void GetImplementedTypesTest()
        {
            string assemblyFile = AppDomain.CurrentDomain.BaseDirectory + "\\Files\\Jasen.Framework.Oracle.dll";
            IEnumerable<Type> types = AssemblyUtility.GetImplementdTypes<DataTable>(assemblyFile);
            Assert.IsNotNull(types);
            int count = 0;
            foreach (var type in types)
            {
                Assert.IsTrue(type.IsSubclassOf(typeof(DataTable)));
                Assert.IsFalse(type.IsAbstract);
                Assert.IsFalse(type.IsInterface);
                count++;
            }
            Assert.AreEqual(1, count);
        }

        [TestMethod()]
        public void GetImplementdTypesByDirectoryTest()
        {
            string assemblyDir = AppDomain.CurrentDomain.BaseDirectory + "\\Files\\";
            IEnumerable<Type> types = AssemblyUtility.GetImplementdTypesByDirectory<DataTable>(assemblyDir);
            Assert.IsNotNull(types);
            int count = 0;
            foreach (var type in types)
            {
                Assert.IsTrue(type.IsSubclassOf(typeof(DataTable)));
                Assert.IsFalse(type.IsAbstract);
                Assert.IsFalse(type.IsInterface);
                count++;
            }
            Assert.AreEqual(3, count);
        }
    }

五、总结

全文中主要围绕AssemblyUtility通用类来进行讲解的，仅仅是插件开发的一个思路。具体应用的话，应该相对来说比较直接，在客户端获取相应的类型集合以及对象集合，然后再执行这些集合的具体操作即可。其中，实现的组件（插件）放置在指定的目录下，通过AssemblyUtility类即可动态加载目录下的程序集，从而获取到指定类型的数据。具体执行什么操作，实现什么功能，这些都是在组件（插件）中实现即可。

源代码下载：C#插件开发模型源代码

本文链接