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

最新推荐文章于 2022-08-19 17:21:40 发布
原创最新推荐文章于 2022-08-19 17:21:40 发布 · 2.2k 阅读
CC 4.0 BY-SA版权
文章标签：
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<Student>();
         //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<Student>.Where(predicate).ToList();
        /// 
        /// 
        /// </summary>
        public static partial class Extention
        {
            #region 拓展AndIf与AndOr

            /// <summary>
            /// 符合条件则And
            /// </summary>
            /// <typeparam name="T">实体类型</typeparam>
            /// <param name="left">原表达式</param>
            /// <param name="need">是否符合条件</param>
            /// <param name="right">新表达式</param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> AndIf<T>(this Expression<Func<T, bool>> left, bool need, Expression<Func<T, bool>> right)
            {
                if (need)
                {
                    // return left.And(right);
                    return left;
                }
                else
                {
                    return left;
                }
            }

            public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
            {
                return first.AndAlso<T>(second, Expression.AndAlso);
            }
            public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
            {
                return first.AndAlso<T>(second, Expression.OrElse);
            }
            private static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2, Func<Expression, Expression, BinaryExpression> 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<T, bool>>(
                    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);
                }
            }

            /// <summary>
            /// 符合条件则Or
            /// </summary>
            /// <typeparam name="T">实体类型</typeparam>
            /// <param name="left">原表达式</param>
            /// <param name="need">是否符合条件</param>
            /// <param name="right">新表达式</param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> OrIf<T>(this Expression<Func<T, bool>> left, bool need, Expression<Func<T, bool>> right)
            {
                if (need)
                {
                    // return left.Or(right);
                    return left;
                }
                else
                {
                    return left;
                }
            }

            #endregion

            #region 拓展BuildExtendSelectExpre方法

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

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

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

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

            /// <summary>
            /// 组合继承属性选择表达式树,4个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,5个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,6个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="T6">拓展类型6</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, T6, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, T6, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, T6, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, T6, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,7个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="T6">拓展类型6</typeparam>
            /// <typeparam name="T7">拓展类型7</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, T6, T7, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, T6, T7, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,8个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="T6">拓展类型6</typeparam>
            /// <typeparam name="T7">拓展类型7</typeparam>
            /// <typeparam name="T8">拓展类型8</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,9个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="T6">拓展类型6</typeparam>
            /// <typeparam name="T7">拓展类型7</typeparam>
            /// <typeparam name="T8">拓展类型8</typeparam>
            /// <typeparam name="T9">拓展类型9</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>>(expression);
            }

            #endregion

            #region 私有成员

            private static Expression<TDelegate> GetExtendSelectExpre<TBase, TResult, TDelegate>(Expression<TDelegate> expression)
            {
                NewExpression newBody = Expression.New(typeof(TResult));
                MemberInitExpression oldExpression = (MemberInitExpression)expression.Body;

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

                List<MemberBinding> newBindings = new List<MemberBinding>();
                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<TDelegate>(body, oldParamters);

                return resExpression;
            }

            #endregion
        }

        /// <summary>
        /// 继承ExpressionVisitor类，实现参数替换统一
        /// </summary>
        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;
                }
            }
        }
    }

}