Linq to sql 动态拼接参数

最新推荐文章于 2024-07-19 09:45:38 发布

hezheqiang

最新推荐文章于 2024-07-19 09:45:38 发布

阅读量490

点赞数

分类专栏： linq 文章标签： sql linq 数据库

本文链接：https://blog.csdn.net/hezheqiang/article/details/125891885

版权

linq 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

该博客介绍了如何在C#中利用动态表达式进行数组条件的查询操作，通过`ExpressionUtility`类提供的`Compose`、`And`、`Or`方法，实现了多个条件的逻辑组合，并在`WhereOR`方法中应用，支持对数组中的多个值进行并集筛选。示例代码展示了如何根据输入的金额范围数组动态构建并执行查询条件。

摘要由CSDN通过智能技术生成

业务需求，查询条件有一项为数组，需要根据数组中的值对数据筛选取并集。

一、工具类

 /// <summary>
    /// 用于多条件动态查询
    /// </summary>
    public static class ExpressionUtility
    {
        public static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
        {
            // 构建参数映射(从第二个参数到第一个参数)
            var map = first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f);
            // 用第一个lambda表达式中的参数替换第二个lambda表达式中的参数
            var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);
            // 将lambda表达式体的组合应用于第一个表达式中的参数 
            return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
        }
        /// <summary>
        /// 动态And
        /// </summary>
        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        {
            return first.Compose(second, Expression.AndAlso);
        }
        /// <summary>
        /// 动态Or
        /// </summary>
        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
        {
            return first.Compose(second, Expression.Or);
        }
        /// <summary>
        /// 传入条件之间为OR查询
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="predicates"></param>
        /// <returns></returns>
        public static IQueryable<T> WhereOR<T>(this IQueryable<T> source, params Expression<Func<T, bool>>[] predicates)
        {
            if (source == null) throw new ArgumentNullException("source");
            if (predicates == null) throw new ArgumentNullException("predicates");
            if (predicates.Length == 0) return source.Where(x => false); // no matches!
            if (predicates.Length == 1) return source.Where(predicates[0]); // simple

            var param = Expression.Parameter(typeof(T), "x");
            Expression body = Expression.Invoke(predicates[0], param);
            for (int i = 1; i < predicates.Length; i++)
            {
                body = Expression.OrElse(body, Expression.Invoke(predicates[i], param));
            }
            var lambda = Expression.Lambda<Func<T, bool>>(body, param);
            return source.Where(lambda);
        }
    }
    public class ParameterRebinder : ExpressionVisitor
    {
        private readonly Dictionary<ParameterExpression, ParameterExpression> map;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="map"></param>
        public ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
        {
            this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="map"></param>
        /// <param name="exp"></param>
        /// <returns></returns>
        public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
        {
            return new ParameterRebinder(map).Visit(exp);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        protected override Expression VisitParameter(ParameterExpression p)
        {
            ParameterExpression replacement;
            if (map.TryGetValue(p, out replacement))
            {
                p = replacement;
            }
            return base.VisitParameter(p);
        }
    }

二、调用方法




            var amountParams = new Expression<Func<Demo, bool>>[input.amount.Count];

            for (int i = 0; i < input.amount.Count; i++)
            {

                if (input.amount[i].IndexOf('-') <= 0)
                {
                    continue;
                }

                var amountStart = Convert.ToDecimal(input.amount[i].Split("-")[0]);
                var amountEnd = Convert.ToDecimal(input.amount[i].Split("-")[1]);

                amountParams[i] = t => t.amount >= amountStart && t.amount < amountEnd;

            }

            demo = demo.WhereOR(amountParams);