第一版

schangxiang@126.com

2025-05-13 02e4293d7baa69c961730191ec3eef22c96bee84

 Weben_CMSרÓôúÂëÉú³ÉÆ÷/queryExtensions/CmsQueryExtensions/Extension/DynamicSearchParameters/PredicateExtensions/PredicateExtensions.cs

@@ -40,9 +40,13 @@
            return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
        }

        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        //public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        //{
        //    return first.Compose(second, Expression.And);
        //}
        public static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        {
            return first.Compose(second, Expression.And);
            return first.Compose(second, Expression.AndAlso);
        }

        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
@@ -77,6 +81,47 @@
            return finalExpression;
        }

        ///// <summary>
        ///// (模糊查询)拼接成 c.Name.contains("1111")||c.Code.Contains("1111")||c.Address.Contains("1111")) å½¢å¼
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="options"></param>
        ///// <param name="fieldName"></param>
        ///// <returns></returns>
        //public static Expression<Func<T, bool>> GetConditionExpressionForFuzzyQuery<T>(string[] fieldNames, string fieldValue)
        //{
        //    try
        //    {
        //        ParameterExpression left = Expression.Parameter(typeof(T), "c");//c=>
        //        Expression expression = Expression.Constant(true);//修改为true，解决公共模糊查询的问题 
        //        foreach (var fieldName in fieldNames)
        //        {
        //            try
        //            {
        //                Expression right = Expression.Call
        //                   (
        //                      Expression.Property(left, typeof(T).GetProperty(fieldName)),  //c.DataSourceName
        //                      typeof(string).GetMethod("Contains", new Type[] { typeof(string) }),// åå°„使用.Contains()方法                         
        //                      Expression.Constant(fieldValue)           // .Contains(fieldValue)
        //                   );
        //                expression = Expression.Or(right, expression);//c.AAA.contain("") || c.BBB.contain("") 
        //            }
        //            catch (Exception ex)
        //            {
        //                throw new Exception($"参数{fieldName}匹配关键字查询时失败:" + ex.Message);
        //            }
        //        }
        //        Expression<Func<T, bool>> finalExpression
        //            = Expression.Lambda<Func<T, bool>>(expression, new ParameterExpression[] { left });
        //        return finalExpression;
        //    }
        //    catch (Exception)
        //    {
        //        throw;
        //    }
        //}


        /// <summary>
        /// (模糊查询)拼接成 c.Name.contains("1111")||c.Code.Contains("1111")||c.Address.Contains("1111")) å½¢å¼
        /// </summary>
@@ -86,35 +131,58 @@
        /// <returns></returns>
        public static Expression<Func<T, bool>> GetConditionExpressionForFuzzyQuery<T>(string[] fieldNames, string fieldValue)
        {
            try
            if (fieldNames == null || fieldNames.Length == 0)
            {
                ParameterExpression left = Expression.Parameter(typeof(T), "c");//c=>
                Expression expression = Expression.Constant(false);
                foreach (var fieldName in fieldNames)
                throw new ArgumentException("至少需要指定一个字段名", nameof(fieldNames));
            }

            if (string.IsNullOrEmpty(fieldValue))
            {
                // ç©ºå€¼æŸ¥è¯¢è¿”回总是返回false的表达式
                var parameter2 = Expression.Parameter(typeof(T), "c");
                return Expression.Lambda<Func<T, bool>>(Expression.Constant(false), parameter2);
            }

            ParameterExpression parameter = Expression.Parameter(typeof(T), "c");
            Expression? expression = null;

            foreach (var fieldName in fieldNames)
            {
                try
                {
                    try
                    var propertyInfo = typeof(T).GetProperty(fieldName);

                    if (propertyInfo == null)
                    {
                        Expression right = Expression.Call
                           (
                              Expression.Property(left, typeof(T).GetProperty(fieldName)),  //c.DataSourceName
                              typeof(string).GetMethod("Contains", new Type[] { typeof(string) }),// åå°„使用.Contains()方法                         
                              Expression.Constant(fieldValue)           // .Contains(fieldValue)
                           );
                        expression = Expression.Or(right, expression);//c.AAA.contain("") || c.BBB.contain("") 
                        throw new ArgumentException($"类型 {typeof(T).Name} ä¸åŒ…含属性 {fieldName}");
                    }
                    catch (Exception ex)

                    if (propertyInfo.PropertyType != typeof(string))
                    {
                        throw new Exception($"参数{fieldName}匹配关键字查询时失败:" + ex.Message);
                        throw new ArgumentException($"属性 {fieldName} ä¸æ˜¯å­—符串类型");
                    }

                    var propertyAccess = Expression.Property(parameter, propertyInfo);
                    var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });
                    var searchExpression = Expression.Call(propertyAccess, containsMethod!, Expression.Constant(fieldValue));

                    expression = expression == null
                        ? searchExpression
                        : Expression.OrElse(expression, searchExpression);
                }
                Expression<Func<T, bool>> finalExpression
                    = Expression.Lambda<Func<T, bool>>(expression, new ParameterExpression[] { left });
                return finalExpression;
                catch (Exception ex)
                {
                    throw new InvalidOperationException($"处理字段 {fieldName} æ—¶å‡ºé”™", ex);
                }
            }
            catch (Exception)

            if (expression == null)
            {
                throw;
                // å¦‚果所有字段都无效，返回总是返回false的表达式
                return Expression.Lambda<Func<T, bool>>(Expression.Constant(false), parameter);
            }

            return Expression.Lambda<Func<T, bool>>(expression, parameter);
        }

        /// <summary>