对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