如何使用 Entity Framework 构造动态查询表达式

　　一般的程序员做上几年以后, 或多或少的都有些代码的积累, 我也不例外. 作为微软技术程序员, 自从Linq和EF出来之后, 就基本上爱不释手了, 且不说执行效率的问题, 单单就开发效率和代码的可移植性上讲, 都是微软技术常规开发首选无二了. 于是终于丢掉了奴隶社会的.NET三层, 进入了EF的封建制了, 然后, 就发现持久化层的代码越写越少, 越写越精炼, 最后好像简直就是个万金油啊, 拿到哪里哪里可以用. 还有因为Lambda 表达式可以做为查询代码的参数, 就导致, 服务器端单单就数据访问层代码就浓缩到了一个文件中, 而且还不需要写过于复杂的代码就可以写出使用泛型, 适合各种增删改查的动态代码, 如下面的查询:

　　public IQueryable<T> ExecuteQuery<T>(Fun<T, bool> where, Fun<T, string> orderby, int pageIndex, int pageSize, out int total, params string[] includes) where T : class {...}

　　一度感觉心里美美的, 好像世界从此就清净了. 直到后来做Web开发的时候, 发现了一个这套机制难以解决的问题,  那就是如何将查询应用到客户端复杂的过滤条件上了?

　　那为什么不能了? 因为Lambda 表达式本身就是动态委托, 这种类型是不能从客户端(js)构造出来, 作为参数传递到服务器端去执行的, 那么怎么办了?

　　经过一番研究, 终于发现了可实现的方式, 原来在System.Linq.Expressions命名空间下的Expression类提供了大量方法, 用于构造动态语法, 于是从只需要定义一套查询表达式规则, 然后客户端去写表达式, 服务器端收到后把它解析成Lambda表达式就可以被EF执行了, 至此, 好像发现了新大陆一样又欣喜若狂了一番.

　　现在, 随着.NET开源, Oracle和Mysql开始支持EF6, 直到Webapi开始支持oData, 貌似一场新的技术改革又要开始了. 我又投入到了新技术孜孜不倦的追求当中.

　　虽然oData是如此之好用, 以至于从此从客户端接受增删改查什么的都成了浮云,  但是许多程序员还在维护着很多旧代码, 许多新程序员需要技术指导和提高, 许多时间以后我自己或许也会忘记如何去写动态表达式, 所以把核心部分代码贴出来, 大家分享一下, 不喜勿喷哦.

　　DbContext的扩展查询方法:

 1 public static IQueryable<T> ExecuteQuery<T>(this DbContext ctx, QueryExpression query) where T : class
         {
             try
             {
                 IQueryable<T> queryable = ctx.Set<T>();
                 if (query != null)
                 {
                     if (query.Include != null && query.Include.Count != )
                     {
                         foreach (var x in query.Include)
                         {
                             queryable = queryable.Include<T>(query.Include[]);
                         }
                     }
                     ParameterExpression param = Expression.Parameter(typeof(T), CommonClass.Anonymous);
                     if (query.Filter != null && query.Filter.Count != )
                     {
                         Expression filter = Expression.Constant(true);
                         foreach (var x in query.Filter)
                         {
                             filter = filter.AddQueryExpression<T>(param, x);
                         }
                         Expression<Func<T, bool>> where = arg => true;
                         where = where.Update(filter, new List<ParameterExpression> { param });
                         queryable = queryable.Where(where);
                     }
                     if (query.OrderBy != null && query.OrderBy.Count != )
                     {
                         Expression<Func<T, string>> orderBy = arg => CommonClass.StateField;
                         IOrderedQueryable<T> orderByQueryable = queryable.OrderBy(orderBy);
                         foreach (var x in query.OrderBy)
                         {
                             Expression exp = Expression.Property(param, x.Field);
                             orderBy = orderBy.Update(exp, new List<ParameterExpression> { param });
                             orderByQueryable = x.Asc ? orderByQueryable.ThenBy(orderBy) : orderByQueryable.ThenByDescending(orderBy);
                         }
                         queryable = orderByQueryable.AsQueryable<T>();
                     }
                     if (query.Pager != null)
                     {
                         query.Pager.Total = queryable.Count();
                         queryable = queryable.Skip((query.Pager.PageIndex - ) * query.Pager.PageSize).Take(query.Pager.PageSize);
                     }
                 }
                 return queryable;
             }
             catch (Exception ex)
             {
                 throw ex;
             }
         }

 public static Expression AddQueryExpression<T>(this Expression exp, ParameterExpression param, DataFilter filter)
         {
             try
             {
                 if (param != null && filter != null)
                 {
                     Expression mexp = null;
                     BinaryExpression bexp = null;
                     PropertyInfo property = typeof(T).GetProperty(filter.Field);
                     if (property != null)
                     {
                         Type type = property.PropertyType;
                         object value = Convert.ChangeType(filter.Value, type);
                         switch (filter.Operation)
                         {
                             //methods operation
                             case DataOperation.Contains:
                             case DataOperation.StartsWith:
                             case DataOperation.EndsWith:
                                 mexp = Expression.Call(Expression.Property(param, filter.Field), type.GetMethod(filter.Operation.ToString()), Expression.Constant(value));
                                 exp = Expression.AndAlso(exp, mexp);
                                 break;
                             //other operation
                             case DataOperation.Equal:
                                 bexp = Expression.Equal(Expression.Property(param, filter.Field), Expression.Constant(value));
                                 exp = Expression.AndAlso(exp, bexp);
                                 break;
                             case DataOperation.NotEqual:
                                 bexp = Expression.NotEqual(Expression.Property(param, filter.Field), Expression.Constant(value));
                                 exp = Expression.AndAlso(exp, bexp);
                                 break;
                             case DataOperation.GreaterThan:
                                 bexp = Expression.GreaterThan(Expression.Property(param, filter.Field), Expression.Constant(value));
                                 exp = Expression.AndAlso(exp, bexp);
                                 break;
                             case DataOperation.GreaterThanOrEqual:
                                 bexp = Expression.GreaterThanOrEqual(Expression.Property(param, filter.Field), Expression.Constant(value));
                                 exp = Expression.AndAlso(exp, bexp);
                                 break;
                             case DataOperation.LessThan:
                                 bexp = Expression.LessThan(Expression.Property(param, filter.Field), Expression.Constant(value));
                                 exp = Expression.AndAlso(exp, bexp);
                                 break;
                             case DataOperation.LessThanOrEqual:
                                 bexp = Expression.LessThanOrEqual(Expression.Property(param, filter.Field), Expression.Constant(value));
                                 exp = Expression.AndAlso(exp, bexp);
                                 break;
                             default:
                                 break;
                         }
                     }
                 }
                 return exp;
             }
             catch (Exception ex)
             {
                 throw ex;
             }
         }

其中的QueryExpression是我自己定义的查询表达式对象, 可以从客户端传递.

打完收工!