如何使用 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 != 0)
                    {
                        foreach (var x in query.Include)
                        {
                            queryable = queryable.Include<T>(query.Include[0]);
                        }
                    }
                    ParameterExpression param = Expression.Parameter(typeof(T), CommonClass.Anonymous);
                    if (query.Filter != null && query.Filter.Count != 0)
                    {
                        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 != 0)
                    {
                        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 - 1) * 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是我自己定义的查询表达式对象, 可以从客户端传递.

打完收工!