拼接表达式树的原理

简单的表达式树，注释写得很清楚

            //假如我们要拼接x=>x.Id==1，假如x的类型为User
            
            //结果是这样：x=>，x是变量名
            var parameterExp = Expression.Parameter(typeof(User), "x");
            
            //结果是这样：x=>x.Id，这句是为了构建访问属性的表达式
            //上面这句第一个参数是你要取属性的对象表达式。
            //我们要拼的表达式是x=>x.Id==1，==1这块先不管
            //其实就是x=>x.Id，那么其实我们就是对x进行取属性值，而x是parameterExp，
            //第一个参数是parameterExp
            //第二个参数好说，就是属性名
            var propertyExp = Expression.Property(parameterExp, "Id");
            
            //结果是··没有结果，构建一个常量表达式，值为1（LINQ的世界，一切皆表达式树）
            //马上就是关键的一步了
            var constExp = Expression.Constant(1);
            
            //结果是：x=>x.Id==1，这个··还需要解释么，很简单，不是么。创建一个相等的表达式，然后传入左边和右边的表达式
            //当然到这儿还不能用，还需要继续
            var body = Expression.Equal(propertyExp, constExp);
            
            //这句和第二句是我学的时候最难理解的两个地方。这句是将我们的成果封装成能用的
            //第一个参数就是我们的成果
            //第二个参数是实现这个成果所需要的参数，那当然是parameterExp，
            //然后泛型参数Func<User,bool>就是我们想把这个表达式封装成什么样的东西，
            //此时,lambda的类型就是Expression<Fun<User,bool>>，这个时候就能用了
            var lambda = Expression.Lambda<Func<User, bool>>(body, parameterExp);
            

下面来个复杂的

            //假如我们要拼接x=>x.Name.Contains("aaa")，假如x的类型为TEntity

            //结果是这样：x=>，x是变量名
            var parameterExp = Expression.Parameter(typeof(TEntity));

            //结果是这样：x=>x.Name，这句是为了构建访问属性的表达式
            //上面这句第一个参数是你要取属性的对象表达式。
            //我们要拼的表达式是x =>x.Name.Constant("aaa")，.Constant("aaa")这块先不管，其实就是x=>x.Name，
            //那么其实我们就是对x进行取属性值，而x是parameterExp，所以第一个参数是parameterExp，
            //第二个参数好说，就是属性名
            var propertyExp = Expression.Property(parameterExp, "Name");

            //因为我们要拼接的表达式中调用了string类型的Username的Contains方法，所以反射获取string类型的Contains方法
            var containsMethod = typeof(string).GetMethod("Contains", new Type[] { typeof(string) });

            //结果是··没有结果，构建一个常量表达式，值为1（LINQ的世界，一切皆表达式树）
            //马上就是关键的一步了
            var constExp = Expression.Constant("aaa");


            //结果是：x=>x.Name.Contains("aaa")，
            //第一个参数，是要调用哪个实例的方法，这里是propertyExp，
            //第二个是调用哪个方法
            //第三个是参数
            var containsExp = Expression.Call(propertyExp, containsMethod, constExp);

            //这句是将我们的成果封装成能用的，第一个参数就是我们的成果，
            //第二个参数是实现这个成果所需要的参数，那当然是parameterExp，
            //然后泛型参数Func<TEntity, bool>就是我们想把这个表达式封装成什么样的东西，
            //此时,lambda的类型就是Expression<Fun<TEntity, bool>>，这个时候就能用了
            var lambda = Expression.Lambda<Func<TEntity, bool>>(containsExp, parameterExp);
            //现在可以直接使用创建的类型
            tempData = tempData.Where(lambda);

多条件动态排序的写法：

            bool isAsc = pagination.sord.ToLower() == "asc" ? true : false;
            string[] _order = pagination.sidx.Split(',');
            MethodCallExpression resultExp = null;
            var tempData = DbContext.Set<TEntity>().AsQueryable();

            foreach (string item in _order)
            {
                string _orderPart = item;
                _orderPart = Regex.Replace(_orderPart, @"s+", " ");
                string[] _orderArry = _orderPart.Split(' ');
                string _orderField = _orderArry[0];
                bool sort = isAsc;
                if (_orderArry.Length == 2)
                {
                    isAsc = _orderArry[1].ToUpper() == "ASC" ? true : false;
                }
                var parameter = Expression.Parameter(typeof(TEntity), "t");
                var property = typeof(TEntity).GetProperty(_orderField);
                var propertyAccess = Expression.MakeMemberAccess(parameter, property);
                var orderByExp = Expression.Lambda(propertyAccess, parameter);
                resultExp = Expression.Call(typeof(Queryable), isAsc ? "OrderBy" : "OrderByDescending", new Type[] { typeof(TEntity), property.PropertyType }, tempData.Expression, Expression.Quote(orderByExp));
            }



            tempData = tempData.Provider.CreateQuery<TEntity>(resultExp);