Expression＜Func＜T, bool＞＞ 扩展方法的使用方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Linq.Expressions;

namespace ZhaoXi.ASP.NET.MVC5.AuthorityProject.Models
{

    namespace Core.Util
    {

        //用法
         // var predicate = PredicateBuilder.GetTrue();
         //predicate = predicate.And(it => it.id.ToString().Contains(strID));
         //predicate = predicate.And(it => it.Birthday.ToString().Contains(strBir));
         //predicate = predicate.And(it => it.Sex.ToString().Contains(strSex));
         //predicate = predicate.And(it => it.Age == 20);
         //var lst = db.Queryable.Where(predicate).ToList();
        /// 
        /// 
        /// 
        public static partial class Extention
        {
            #region 拓展AndIf与AndOr

            /// 

            /// 符合条件则And
            /// 
            /// 实体类型
            /// 原表达式
            /// 是否符合条件
            /// 新表达式
            /// 
            public static Expression> AndIf(this Expression> left, bool need, Expression> right)
            {
                if (need)
                {
                    // return left.And(right);
                    return left;
                }
                else
                {
                    return left;
                }
            }

            public static Expression> And(this Expression> first, Expression> second)
            {
                return first.AndAlso(second, Expression.AndAlso);
            }
            public static Expression> Or(this Expression> first, Expression> second)
            {
                return first.AndAlso(second, Expression.OrElse);
            }
            private static Expression> AndAlso(this Expression> expr1, Expression> expr2, Func func)
            {
                var parameter = Expression.Parameter(typeof(T));

                var leftVisitor = new ReplaceExpressionVisitor(expr1.Parameters[0], parameter);
                var left = leftVisitor.Visit(expr1.Body);

                var rightVisitor = new ReplaceExpressionVisitor(expr2.Parameters[0], parameter);
                var right = rightVisitor.Visit(expr2.Body);

                return Expression.Lambda>(
                    func(left, right), parameter);
            }
            private class ReplaceExpressionVisitor : ExpressionVisitor
            {
                private readonly Expression _oldValue;
                private readonly Expression _newValue;

                public ReplaceExpressionVisitor(Expression oldValue, Expression newValue)
                {
                    _oldValue = oldValue;
                    _newValue = newValue;
                }

                public override Expression Visit(Expression node)
                {
                    if (node == _oldValue)
                        return _newValue;
                    return base.Visit(node);
                }
            }

            /// 

            /// 符合条件则Or
            /// 
            /// 实体类型
            /// 原表达式
            /// 是否符合条件
            /// 新表达式
            /// 
            public static Expression> OrIf(this Expression> left, bool need, Expression> right)
            {
                if (need)
                {
                    // return left.Or(right);
                    return left;
                }
                else
                {
                    return left;
                }
            }

            #endregion

            #region 拓展BuildExtendSelectExpre方法

            /// 

            /// 组合继承属性选择表达式树,无拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,1个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,2个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 拓展类型2
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,3个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 拓展类型2
            /// 拓展类型3
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,4个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 拓展类型2
            /// 拓展类型3
            /// 拓展类型4
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,5个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 拓展类型2
            /// 拓展类型3
            /// 拓展类型4
            /// 拓展类型5
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,6个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 拓展类型2
            /// 拓展类型3
            /// 拓展类型4
            /// 拓展类型5
            /// 拓展类型6
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,7个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 拓展类型2
            /// 拓展类型3
            /// 拓展类型4
            /// 拓展类型5
            /// 拓展类型6
            /// 拓展类型7
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,8个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 拓展类型2
            /// 拓展类型3
            /// 拓展类型4
            /// 拓展类型5
            /// 拓展类型6
            /// 拓展类型7
            /// 拓展类型8
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            /// 

            /// 组合继承属性选择表达式树,9个拓展参数
            /// TResult将继承TBase的所有属性
            /// 
            /// 原数据类型
            /// 拓展类型1
            /// 拓展类型2
            /// 拓展类型3
            /// 拓展类型4
            /// 拓展类型5
            /// 拓展类型6
            /// 拓展类型7
            /// 拓展类型8
            /// 拓展类型9
            /// 返回类型
            /// 拓展表达式
            /// 
            public static Expression> BuildExtendSelectExpre(this Expression> expression)
            {
                return GetExtendSelectExpre>(expression);
            }

            #endregion

            #region 私有成员

            private static Expression GetExtendSelectExpre(Expression expression)
            {
                NewExpression newBody = Expression.New(typeof(TResult));
                MemberInitExpression oldExpression = (MemberInitExpression)expression.Body;

                ParameterExpression[] oldParamters = expression.Parameters.ToArray();
                List existsProperties = new List();
                oldExpression.Bindings.ToList().ForEach(aBinding =>
                {
                    existsProperties.Add(aBinding.Member.Name);
                });

                List newBindings = new List();
                typeof(TBase).GetProperties().Where(x => !existsProperties.Contains(x.Name)).ToList().ForEach(aProperty =>
                {
                    if (typeof(TResult).GetMembers().Any(x => x.Name == aProperty.Name))
                    {
                        MemberBinding newMemberBinding = null;
                        var valueExpre = Expression.Property(oldParamters[0], aProperty.Name);
                        if (typeof(TBase).IsAssignableFrom(typeof(TResult)))
                        {
                            newMemberBinding = Expression.Bind(aProperty, valueExpre);
                        }
                        else
                        {
                            newMemberBinding = Expression.Bind(typeof(TResult).GetProperty(aProperty.Name), valueExpre);
                        }
                        newBindings.Add(newMemberBinding);
                    }
                });

                newBindings.AddRange(oldExpression.Bindings);

                var body = Expression.MemberInit(newBody, newBindings.ToArray());
                var resExpression = Expression.Lambda(body, oldParamters);

                return resExpression;
            }

            #endregion
        }

        /// 

        /// 继承ExpressionVisitor类，实现参数替换统一
        /// 
        internal class ParameterReplaceVisitor : System.Linq.Expressions.ExpressionVisitor
        {
            public ParameterReplaceVisitor(ParameterExpression paramExpr)
            {
                _parameter = paramExpr;
            }

            //新的表达式参数
            private readonly ParameterExpression _parameter;

            protected override Expression VisitParameter(ParameterExpression p)
            {
                if (p.Type == _parameter.Type)
                {
                    return _parameter;
                }

                else
                {
                    return p;
                }
            }
        }
    }

}