对List进行子查询及分组

    在FaibClass.Data中,DataModelList<T> : List<T>类有三个方法：Select、Group和Compute，可以对集合进行子查询及分组统计，今天就说一其原理。
    本人也看过DataTable的Select方法，不过才浅得很，感觉很是复杂，所以变通了一下，使用动态编译的方式来解决这个问题。
    首先，这两个方法都有一个共同的参数QueryBuilder，使用其构造方法new QueryBuilder(true)，用于在添加查询条件时，添加对应的C#语法语句，再动态的生成代码查询出所要的结果。比如添加条件 
    QueryBuilder qb = new QueryBuilder(true);
    qb.Append(QueryRelation.And, QueryCompare.Greater, TB_BUY_BILL._BUY_TIME, new DateTime(2009, 4, 29));
    qb.Append(QueryRelation.And, QueryCompare.Equal, TB_BUY_BILL._BILL_STATE, true);
时，已经生成了一条C#语句
    {0}.BUY_TIME > DateTime.Parse("2009, 4, 29") and {0}.BILL_STATE == true
    其中的{0}要在代码编译时才发挥作用，用实体对象替换。

    一、Select方法

        /// <summary>
        /// 获取按照指定的与筛选条件相匹配的子集合。
         /// </summary>
        /// <param name="queryBuilder">要用来筛选的条件。</param>
        /// <returns></returns>
        public DataModelList<T> Select(QueryBuilder queryBuilder)
        {
            object result = new ExpressionCompiler().ComplieSelect(this, queryBuilder);
            if (result == null) return null;
            return (DataModelList<T>)result;
        }

ExpressionCompiler是一个表达示编译类，ComplieSelect的方法如下：

 1         /// <summary>
 2         /// 编译查询子集合表达示。
 3         /// </summary>
 4         /// <param name="list">进行筛选的数据集合。</param>
 5         /// <param name="queryBuilder">过滤查询器。</param>
 6         /// <returns></returns>
 7         internal IDataModelList ComplieSelect(IDataModelList list, QueryBuilder queryBuilder)
 8         {
 9             if (queryBuilder == null) return list;
10             if (queryBuilder.expressionBuilder.Length == 0) return list;
11             StringBuilder code = new StringBuilder();
12             string expression = FormatExpression(list.ModelType, queryBuilder);
13             code.Append(@"
14                 public IDataModelList Execute(IList list)
15                 {
16                     //创建子集合对象
17                     IDataModelList result = (IDataModelList)Activator.CreateInstance(list.GetType());
18                     //循环当前集合
19                     foreach(object item in list)
20                     {
21                         BaseModel model = (BaseModel)item;
22                         //判断表达示，如果为真添加到子集合
23                         if (" + expression + @")
24                         {
25                             result.Add(model);
26                         }
27                     }
28                     return result;
29                 }
30             ");
31             //执行编译后返回结果
32             object result = CompileCode("ComplieSelect", code.ToString(), list);
33             if (result == null) return null;
34             return (IDataModelList)result;
35         }

FormatExpression即是将{0}替换为实体对象：

 1         /// <summary>
 2         /// 格式化表达示。
 3         /// </summary>
 4         /// <param name="type"></param>
 5         /// <param name="queryBuilder"></param>
 6         /// <returns></returns>
 7         private string FormatExpression(Type type, QueryBuilder queryBuilder)
 8         {
 9             //将'号转为"
10             string expression = queryBuilder.expressionBuilder.ToString().Replace("'", "\"");
11             //替换{0}为Model.GetValue
12             foreach (PropertyInfo pinfo in type.GetProperties())
13             {
14                 if (expression.IndexOf("{0}." + pinfo.Name) != -1)
15                 {
16                     //布尔
17                     if (pinfo.PropertyType == typeof(Boolean))
18                     {
19                         expression = expression.Replace("{0}." + pinfo.Name, "((bool)model.GetValue(\"" + pinfo.Name + "\") ? 1 : 0)");
20                     }
21                     //枚举
22                     else if (pinfo.PropertyType.BaseType == typeof(Enum))
23                     {
24                         expression = expression.Replace("{0}." + pinfo.Name, "(int)model.GetValue(\"" + pinfo.Name + "\")");
25                     }
26                     else
27                     {
28                         expression = expression.Replace("{0}." + pinfo.Name, "(" + pinfo.PropertyType + ")model.GetValue(\"" + pinfo.Name + "\")");
29                     }
30                 }
31             }
32             return expression;
33         }

    二、Group方法。
    首先定义了一个类及集合来保存分组的结果：

 1 using System;
 2 using System.Collections.Generic;
 3 
 4 namespace FaibClass.Data
 5 {
 6     /// <summary>
 7     /// 数据分组集合。
 8     /// </summary>
 9     public class DataGroupCollection : List<DataGroup>
10     {
11         /// <summary>
12         /// 索引器。
13         /// </summary>
14         /// <param name="value">分组的值。</param>
15         /// <returns></returns>
16         public DataGroup this[object value]
17         {
18             get 
19             {
20                 foreach (DataGroup group in this)
21                 {
22                     if (group.Value.Equals(value))
23                         return group;
24                 }
25                 return null;
26             }
27         }
28 
29         /// <summary>
30         /// 检查分组值是否存在于本集合中。
31         /// </summary>
32         /// <param name="value">分组的值。</param>
33         /// <returns></returns>
34         public bool ContainsKey(object value)
35         {
36             foreach(DataGroup group in this)
37             {
38                 if (group.Value.Equals(value))
39                     return true;
40             }
41             return false;
42         }
43 
44         /// <summary>
45         /// 添加一个数据分组。
46         /// </summary>
47         /// <param name="value">分组的值。</param>
48         /// <param name="list">分组后的集合。</param>
49         public void Add(object value, IDataModelList list)
50         {
51             DataGroup group = new DataGroup();
52             group.Value = value;
53             group.List = list;
54             base.Add(group);
55         }
56     }
57 
58     /// <summary>
59     /// 数据分组。
60     /// </summary>
61     public class DataGroup
62     {
63         private object value;
64         private IDataModelList list;
65 
66         /// <summary>
67         /// 值。
68         /// </summary>
69         public object Value
70         {
71             get { return value; }
72             set { this.value = value; }
73         }
74 
75         /// <summary>
76         /// 数据集合。
77         /// </summary>
78         public IDataModelList List
79         {
80             get { return list; }
81             set { list = value; }
82         }
83     }
84 }
85 

下面是Compute方法的原型：

 1         /// <summary>
 2         /// 对当前数据集合进行分组。
 3         /// </summary>
 4         /// <param name="memberName">参照分组的字段名称。</param>
 5         /// <returns></returns>
 6         public DataGroupCollection Group(string memberName)
 7         {
 8             PropertyInfo pinfo = ModelType.GetProperty(memberName, BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
 9             if (pinfo == null)
10             {
11                 throw new InvalidColumnException(memberName);
12             }
13             DataGroupCollection coll = new DataGroupCollection();
14             foreach (T t in this)
15             {
16                 BaseModel model = (BaseModel)t;
17                 object value = model.GetValue(memberName);
18                 if (!coll.ContainsKey(value))
19                 {
20                     coll.Add(value, new DataModelList<T>());
21                 }
22                 coll[value].List.Add(t);
23             }
24             return coll;
25         }

    三、Compute方法
    首先是一个计算类别的枚举

 1     /// <summary>
 2     /// 计算类别。
 3     /// </summary>
 4     public enum ComputeType
 5     {
 6         /// <summary>
 7         /// 求个数。
 8         /// </summary>
 9         Count = 0,
10         /// <summary>
11         /// 求和。
12         /// </summary>
13         Sum,
14         /// <summary>
15         /// 求平均值。
16         /// </summary>
17         Average,
18         /// <summary>
19         /// 求最大值。
20         /// </summary>
21         Max,
22         /// <summary>
23         /// 求最小值。
24         /// </summary>
25         Min
26     }

一个表达示类

 1     /// <summary>
 2     /// 计算表达示。
 3     /// </summary>
 4     public class ComputeExpression
 5     {
 6         private ComputeType countType;
 7         private string field;
 8         private decimal result;
 9 
10         /// <summary>
11         /// 构造表达示。
12         /// </summary>
13         /// <param name="field">要计算的字段名。</param>
14         /// <param name="countType">计算的类别。</param>
15         public ComputeExpression(string field, ComputeType countType)
16         {
17             this.field = field;
18             this.countType = countType;
19         }
20 
21         /// <summary>
22         /// 计算的类别。
23         /// </summary>
24         public ComputeType ComputeType
25         {
26             get { return countType; }
27             set { countType = value; }
28         }
29 
30         /// <summary>
31         /// 要计算的字段名。
32         /// </summary>
33         public string Field
34         {
35             get { return field; }
36             set { field = value; }
37         }
38 
39         /// <summary>
40         /// 返回计算的结果。
41         /// </summary>
42         public decimal Result
43         {
44             get { return result; }
45             set { result = value; }
46         }
47     }

Compute方法原型：

 1         /// <summary>
 2         /// 计算用来传递筛选条件的当前集合的给定表达式。
 3         /// </summary>
 4         /// <param name="expression">要计算的表达式。</param>
 5         /// <param name="queryBuilder">要限制在表达式中进行计算的筛选器。</param>
 6         public void Compute(ComputeExpression[] expression, QueryBuilder queryBuilder)
 7         {
 8             if (expression == null) return;
 9             new ExpressionCompiler().ComplieCompute(this, expression, queryBuilder);
10         }
11 

再来看看编译代码的ComplieCompute方法：

 1         /// <summary>
 2         /// 编译计算统计表达示。
 3         /// </summary>
 4         /// <param name="list"></param>
 5         /// <param name="expressionArray"></param>
 6         /// <param name="queryBuilder"></param>
 7         internal void ComplieCompute(IDataModelList list, ComputeExpression[] expressionArray, QueryBuilder queryBuilder)
 8         {
 9             foreach (ComputeExpression exp in expressionArray)
10             {
11                 PropertyInfo pinfo = list.ModelType.GetProperty(exp.Field, BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
12                 if (pinfo == null)
13                 {
14                     throw new InvalidColumnException(exp.Field);
15                 }
16                 if (exp.ComputeType != ComputeType.Count)
17                 {
18                     if (!Utility.IsNumberType(pinfo.PropertyType))
19                     {
20                         throw new Exception("非数字型字段不能参与计算。");
21                     }
22                 }
23             }
24 
25             StringBuilder code = new StringBuilder();
26             string expression = string.Empty;
27             //没有查询条件，则条件为true
28             if (queryBuilder == null)
29             {
30                 expression = "true";
31             }
32             else if (queryBuilder.Length == 0)
33             {
34                 expression = "true";
35             }
36             else
37             {
38                 expression = FormatExpression(list.ModelType, queryBuilder);
39             }
40             code.Append(@"
41                 public bool Execute(ComputeExpression[] expressionArray, IList list)
42                 {
43                     int count = 0;
44                     //初始值
45                     foreach(ComputeExpression exp in expressionArray)
46                     {
47                         if (exp.ComputeType == ComputeType.Min)
48                             exp.Result = decimal.MaxValue;
49                         else if (exp.ComputeType == ComputeType.Max)
50                             exp.Result = decimal.MinValue;
51                     }
52                     foreach(object item in list)
53                     {
54                         BaseModel model = (BaseModel)item;
55                         //如果条件为真
56                         if (" + expression + @")
57                         {
58                             foreach(ComputeExpression exp in expressionArray)
59                             {
60                                 switch (exp.ComputeType)
61                                 {
62                                     case ComputeType.Sum:
63                                     case ComputeType.Average:
64                                         exp.Result += (decimal)model.GetValue(exp.Field);
65                                         break;
66                                     case ComputeType.Max:
67                                         exp.Result = Math.Max((decimal)model.GetValue(exp.Field), exp.Result);
68                                         break;
69                                     case ComputeType.Min:
70                                         exp.Result = Math.Min((decimal)model.GetValue(exp.Field), exp.Result);
71                                         break;
72                                 }
73                             }
74                             count ++;
75                         }
76                     }
77                     foreach(ComputeExpression exp in expressionArray)
78                     {
79                         if (exp.ComputeType == ComputeType.Count)
80                             exp.Result = count;
81                         else if (exp.ComputeType == ComputeType.Average)
82                             exp.Result = count == 0 ? 0 : exp.Result / count;
83                     }
84                     return true;
85                 }
86             ");
87             CompileCode("ComplieCompute", code.ToString(), expressionArray, list);
88         }
89