ERP/NetLibrary/IQueryBuilder.cs


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

namespace LinqDemo
{
    public static class QueryBuilder
    {
        public static IQueryBuilder<T> Create<T>()
        {
            return new QueryBuilder<T>();
        }
    }

    class QueryBuilder<T> : IQueryBuilder<T>
    {
        private Expression<Func<T, bool>> predicate;
        Expression<Func<T, bool>> IQueryBuilder<T>.Expression
        {
            get
            {
                return predicate;
            }
            set
            {
                predicate = value;
            }
        }

        //public List<ParameterExpression> Parameters { get; set; }

        public QueryBuilder()
        {
            predicate = PredicateExtensions.True<T>();
            //Parameters = new List<ParameterExpression>();
        }

    }

    /// <summary>
    /// 动态查询条件创建者
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IQueryBuilder<T>
    {
        Expression<Func<T, bool>> Expression { get; set; }
        //List<ParameterExpression> Parameters { get; set; }
    }

    public static class IQueryBuilderExtensions
    {
        /// <summary>
        /// 建立 Between 查询条件
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="q">动态查询条件创建者</param>
        /// <param name="property">属性</param>
        /// <param name="from">开始值</param>
        /// <param name="to">结束值</param>
        /// <returns></returns>

        public static IQueryBuilder<T> Between<T, P>(this IQueryBuilder<T> q, Expression<Func<T, P>> property, P from, P to)
        {

            var parameter = property.GetParameters();

            var constantFrom = Expression.Constant(from);

            var constantTo = Expression.Constant(to);

            Type type = typeof(P);

            Expression nonNullProperty = property.Body;

            //如果是Nullable<X>类型，则转化成X类型

            if (IsNullableType(type))
            {

                type = GetNonNullableType(type);

                nonNullProperty = Expression.Convert(property.Body, type);

            }

            System.Linq.Expressions.BinaryExpression c1=null;
            System.Linq.Expressions.BinaryExpression c2=null;
            System.Linq.Expressions.BinaryExpression c=null;
            if (from != null)
            c1 = Expression.GreaterThanOrEqual(nonNullProperty, constantFrom);
            if (to != null)
            c2 = Expression.LessThanOrEqual(nonNullProperty, constantTo);

            if(from !=null && to != null)
                c = Expression.AndAlso(c1, c2);

            if (from != null && to == null)
                c = c1;

            if (from == null && to != null)
                c = c2;

            Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(c, parameter);

            q.Expression = q.Expression.And(lambda);

            return q;

        }



        /// <summary>
        /// 建立 Like ( 模糊 ) 查询条件
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="q">动态查询条件创建者</param>
        /// <param name="property">属性</param>
        /// <param name="value">查询值</param>
        /// <returns></returns>
        #region
        public static IQueryBuilder<T> Like<T>(this IQueryBuilder<T> q, Expression<Func<T, string>> property, string value)
        {

            value = value.Trim();

            if (!string.IsNullOrEmpty(value))
            {

                var parameter = property.GetParameters();
                Expression<Func<T, bool>> lambda = null;
                //MethodCallExpression methodExp = Expression.Call(property.Body,
                //    typeof(string).GetMethod("Contains", new Type[] { typeof(string) }),
                //    Expression.Constant(value)
                //);
                var c = typeof(string).GetMethod("IndexOf", new[] { typeof(string) });
                MethodCallExpression methodExp = Expression.Call(property.Body,
                c,
                Expression.Constant(value)
                );
                var condition = Expression.NotEqual(Expression.Convert(methodExp, typeof(int)), Expression.Constant(-1));

                lambda = Expression.Lambda<Func<T, bool>>(condition, parameter);
                //MethodCallExpression methodExp = Expression.Call(null, typeof(SqlMethods).GetMethod("Like",

                //    new Type[] { typeof(string), typeof(string) }), property.Body, constant);

                //Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(methodExp, parameter);
                //Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(methodExp, parameter);


                q.Expression = q.Expression.And(lambda);

            }

            return q;

        }
        #endregion

        /// <summary>
        /// 建立 OrLike ( 模糊 ) 查询条件
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="q">动态查询条件创建者</param>
        /// <param name="property">属性</param>
        /// <param name="value">查询值</param>
        /// <returns></returns>
        
        private static Expression<Func<T, bool>> OrLike<T>(this IQueryBuilder<T> q, Expression<Func<T, string>> property, string value)
        {
            #region
            //List<Expression> Expressions = new List<Expression>();
            var parameter = property.GetParameters();
            Expression<Func<T, bool>> lambda = null;

            if (!string.IsNullOrEmpty(value))
                {
                    //var propertyBody = GetMemberExpression(q, property);
                    MethodCallExpression methodExp = Expression.Call(property.Body,
                    typeof(string).GetMethod("Contains", new Type[] { typeof(string) }),
                    Expression.Constant(value)
                    //typeof(LinqToSqlShared).GetMethod("IndexOf", new[] { typeof(string) }), Expression.Constant(value)
                    );
                    //Expressions.Add(methodExp);
                    //var condition = Expression.GreaterThan(methodExp, Expression.Constant(0));

                    lambda = Expression.Lambda<Func<T, bool>>(methodExp, parameter);
                }

            //Expression<Func<T, bool>> lambda = null;
            //if (Expressions.Count != 0)
            //{
            //    Expression expression = Expressions.Aggregate((e1, e2) => Expression.Or(e1, e2));
            //    lambda = Expression.Lambda<Func<T, bool>>(expression, parameter);
            //    //q.Expression = q.Expression.And(lambda);

            //}

            return lambda;
            #endregion
        }


        private static Expression<Func<T, bool>> OrCharIndex<T>(this IQueryBuilder<T> q, Expression<Func<T, string>> property, string value)
        {
            #region

            var parameter = property.GetParameters();
            Expression<Func<T, bool>> lambda = null;

            if (!string.IsNullOrEmpty(value))
            {
                var c = typeof(string).GetMethod("IndexOf", new[] { typeof(string) });
                MethodCallExpression methodExp = Expression.Call(property.Body,
                c,
                Expression.Constant(value)
                );
                var condition = Expression.NotEqual(Expression.Convert(methodExp, typeof(int)), Expression.Constant(-1));

                lambda = Expression.Lambda<Func<T, bool>>(condition, parameter);
            }

            return lambda;
            #endregion
        }

        /// <summary>
        /// 建立 Equals ( 相等 ) 查询条件
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="q">动态查询条件创建者</param>
        /// <param name="property">属性</param>
        /// <param name="value">查询值</param>
        /// <returns></returns>
        public static IQueryBuilder<T> Equals<T, P>(this IQueryBuilder<T> q, Expression<Func<T, P>> property, P value)
        {

            var parameter = property.GetParameters();

            var constant = Expression.Constant(value);

            Type type = typeof(P);

            Expression nonNullProperty = property.Body;

            //如果是Nullable<X>类型，则转化成X类型

            if (IsNullableType(type))
            {

                type = GetNonNullableType(type);

                nonNullProperty = Expression.Convert(property.Body, type);

            }

            var methodExp = Expression.Equal(nonNullProperty, constant);

            Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(methodExp, parameter);

            q.Expression = q.Expression.And(lambda);

            return q;

        }



        /// <summary>
        /// 建立 In 查询条件
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="q">动态查询条件创建者</param>
        /// <param name="property">属性</param>
        /// <param name="valuse">查询值</param> 
        /// <returns></returns>

        public static IQueryBuilder<T> In<T, P>(this IQueryBuilder<T> q, Expression<Func<T, P>> property, IEnumerable<P> values)
        {

            if (values != null )
            {

                var parameter = property.GetParameters();

                var constant = Expression.Constant(values);

                Type type = typeof(P);

                Expression nonNullProperty = property.Body;

                //如果是Nullable<X>类型，则转化成X类型

                if (IsNullableType(type))
                {

                    type = GetNonNullableType(type);

                    nonNullProperty = Expression.Convert(property.Body, type);

                }

                Expression<Func<IEnumerable<P>, P, bool>> InExpression = (list, el) => list.Contains(el);

                var methodExp = InExpression;

                var invoke = Expression.Invoke(methodExp, constant, property.Body);

                Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(invoke, parameter);

                q.Expression = q.Expression.And(lambda);

            }

            return q;

        }

        /// <summary>
        /// 建立 NotIn 查询条件
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="q">动态查询条件创建者</param>
        /// <param name="property">属性</param>
        /// <param name="valuse">查询值</param> 
        /// <returns></returns>

        public static IQueryBuilder<T> NotIn<T, P>(this IQueryBuilder<T> q, Expression<Func<T, P>> property, IEnumerable<P> values)
        {

            if (values != null )
            {

                var parameter = property.GetParameters();

                var constant = Expression.Constant(values);

                Type type = typeof(P);

                Expression nonNullProperty = property.Body;

                //如果是Nullable<X>类型，则转化成X类型

                if (IsNullableType(type))
                {

                    type = GetNonNullableType(type);

                    nonNullProperty = Expression.Convert(property.Body, type);

                }

                Expression<Func<IEnumerable<P>, P, bool>> InExpression = (list, el) => !list.Contains(el);

                var methodExp = InExpression;

                var invoke = Expression.Invoke(methodExp, constant, property.Body);

                Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(invoke, parameter);

                q.Expression = q.Expression.And(lambda);

            }

            return q;

        }


        /// <summary>
        /// FullText查询，多字段 多字符串
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="q"></param>
        /// <param name="expression">支持1 2 3 以空格作为分隔符</param>
        /// <param name="properties">查询字段属性 o => o.xxx1,o => o.xxx2...</param>
        /// <returns></returns>
        public static IQueryBuilder<T> FullText<T>(this IQueryBuilder<T> q, string expression, List<Expression<Func<T, string>>> properties)
        {
            if (string.IsNullOrEmpty(expression))
                return q;
            if (properties == null || properties.Count() == 0 )
                return q;

            string[] es = expression.Split(' ');
            List<Expression<Func<T, bool>>> lambda1 = new List<Expression<Func<T,bool>>>();
            foreach (var str in es)
            {
                List<Expression<Func<T, bool>>> lambda2 = new List<Expression<Func<T,bool>>>();
                foreach (var property in properties)
                {
                    var a = q.OrCharIndex(property, str);                   
                    
                    if(a != null)
                        lambda2.Add(a);
                }
                if (lambda2.Count != 0)
                    lambda1.Add(lambda2.Aggregate((e1, e2) => e1.Or(e2)));
            }
            //var b = lambda1.Aggregate((e1, e2) => e1.Or(e2));
            //q.Expression = q.Expression.And(b);
            foreach (var b in lambda1)
                q.Expression = q.Expression.And(b);
            
            return q;
        }

        private static ParameterExpression[] GetParameters<T, S>(this Expression<Func<T, S>> expr)
        {
            return expr.Parameters.ToArray();
        }

        static bool IsNullableType(Type type)
        {
            return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
        }


        static Type GetNonNullableType(Type type)
        {
            return type.GetGenericArguments()[0];
            //return IsNullableType(type) ? type.GetGenericArguments()[0] : type;
        }

        public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
        {
            foreach (T element in source)
                action(element);
        }

        //EF参数重写
        //private static Expression GetMemberExpression<T, P>(IQueryBuilder<T> q, Expression<Func<T, P>> property)
        //{
        //    if (q.Parameters == null || q.Parameters.Count == 0)
        //    {
        //        property.Parameters.ForEach(
        //            p =>
        //            {
        //                q.Parameters.Add(p);
        //            }
        //            );
        //        return property.Body;
        //    }

        //    ParameterExpressionVisitor visitor = new ParameterExpressionVisitor(q.Parameters[0]);

        //    Expression memberExpr = visitor.ChangeParameter(property.Body);

        //    return memberExpr;
        //}

        //public class ParameterExpressionVisitor : ExpressionVisitor
        //{
        //    private ParameterExpression newParameterExpression;

        //    public ParameterExpressionVisitor(ParameterExpression p)
        //    {
        //        newParameterExpression = p;
        //    }

        //    public Expression ChangeParameter(Expression exp)
        //    {
        //        return Visit(exp);
        //    }

        //    protected override Expression VisitParameter(ParameterExpression p)
        //    {
        //        return newParameterExpression;
        //    }
        //}
    }
}