通过实体框架中的或条件的动态查询

Question

我正在创建一个搜索数据库的应用程序，并允许用户动态添加任何条件（约50个可能），就像以下问题一样：使用实体框架创建动态查询。我目前正在进行一个检查每个条件的搜索，如果不是空白，则将其添加到查询中。

c＃

var query = Db.Names.AsQueryable();
  if (!string.IsNullOrWhiteSpace(first))
      query = query.Where(q => q.first.Contains(first));
  if (!string.IsNullOrWhiteSpace(last))
      query = query.Where(q => q.last.Contains(last));
  //.. around 50 additional criteria
  return query.ToList();

此代码在SQL Server中产生类似于以下的代码（我简化了以便于理解）

sql

SELECT
    [Id],
    [FirstName],
    [LastName],
    ...etc
FROM [dbo].[Names]
WHERE [FirstName] LIKE '%first%'
  AND [LastName] LIKE '%last%'

我现在正在尝试添加一种使用C＃通过C＃生成以下SQL的方法实体框架，但具有或，而不是和，同时仍保持动态添加标准的能力。

sql

SELECT
    [Id],
    [FirstName],
    [LastName],
    ...etc
  FROM [dbo].[Names]
WHERE [FirstName] LIKE '%first%'
  OR [LastName] LIKE '%last%' <-- NOTICE THE "OR"

通常，标准不会大于两个或三个项目以进行查询，但是将它们组合成一个巨大的查询不是一个选择。我尝试了Concat，Union和Intersect，它们只是复制了查询，并与Union一起加入。

是否有一种简单干净的方法可以使用实体框架向动态生成的查询添加“或”条件？

使用我的解决方案编辑-9/29/2015

自发布此信息以来，我注意到这引起了一点关注，所以我决定发布我的解决方案

// Make sure to add required nuget
// PM> Install-Package LinqKit

var searchCriteria = new 
{
    FirstName = "sha",
    LastName = "hill",
    Address = string.Empty,
    Dob = (DateTime?)new DateTime(1970, 1, 1),
    MaritalStatus = "S",
    HireDate = (DateTime?)null,
    LoginId = string.Empty,
};

var predicate = PredicateBuilder.False<Person>();
if (!string.IsNullOrWhiteSpace(searchCriteria.FirstName))
{
    predicate = predicate.Or(p => p.FirstName.Contains(searchCriteria.FirstName));
}

if (!string.IsNullOrWhiteSpace(searchCriteria.LastName))
{
    predicate = predicate.Or(p => p.LastName.Contains(searchCriteria.LastName));
}

// Quite a few more conditions...

foreach(var person in this.Persons.Where(predicate.Compile()))
{
    Console.WriteLine("First: {0} Last: {1}", person.FirstName, person.LastName);
}

Answer 1

您可能正在寻找谓词构建器，它允许您更轻松地控制Where语句。

还有 Dynamic Linq 使您可以像SQL字符串一样提交Where子句，并将其解析为正确的谓词。

Answer 2

虽然Linqkit及其谓词builder的用途广泛，但可以更直接地使用一些简单的实用程序（每个实用程序）作为其他表达式操作操作的基础）：

首先，通用表达式替换器：

public class ExpressionReplacer : ExpressionVisitor
{
    private readonly Func<Expression, Expression> replacer;

    public ExpressionReplacer(Func<Expression, Expression> replacer)
    {
        this.replacer = replacer;
    }

    public override Expression Visit(Expression node)
    {
        return base.Visit(replacer(node));
    }
}

Next，Next，a，简单的实用程序方法将一个参数的用法替换为给定表达式中的另一个参数：

public static T ReplaceParameter<T>(T expr, ParameterExpression toReplace, ParameterExpression replacement)
    where T : Expression
{
    var replacer = new ExpressionReplacer(e => e == toReplace ? replacement : e);
    return (T)replacer.Visit(expr);
}

这是必要的，因为两个不同表达式中的lambda参数实际上是不同的参数当他们有相同的名字时。例如，如果您想结束q =＆gt; q.first.contains（第一个）|| q.last.contains（last），然后q in q.last.contains（last）必须是完全相同的 q在lambda表达式开始时提供。

接下来，我们需要一个通用连接方法，该方法能够连接func＆lt; t，tretern＆gt; - 式lambda表达式以及给定的二进制表达式生成器。

public static Expression<Func<T, TReturn>> Join<T, TReturn>(Func<Expression, Expression, BinaryExpression> joiner, IReadOnlyCollection<Expression<Func<T, TReturn>>> expressions)
{
    if (!expressions.Any())
    {
        throw new ArgumentException("No expressions were provided");
    }
    var firstExpression = expressions.First();
    var otherExpressions = expressions.Skip(1);
    var firstParameter = firstExpression.Parameters.Single();
    var otherExpressionsWithParameterReplaced = otherExpressions.Select(e => ReplaceParameter(e.Body, e.Parameters.Single(), firstParameter));
    var bodies = new[] { firstExpression.Body }.Concat(otherExpressionsWithParameterReplaced);
    var joinedBodies = bodies.Aggregate(joiner);
    return Expression.Lambda<Func<T, TReturn>>(joinedBodies, firstParameter);
}

我们将与expression.or一起使用，但是您可以将相同的方法用于多种目的，例如将数字表达式与expression.ADD.ADD相结合。

最后，将所有内容放在一起，您可以拥有这样的东西：

var searchCriteria = new List<Expression<Func<Name, bool>>();

  if (!string.IsNullOrWhiteSpace(first))
      searchCriteria.Add(q => q.first.Contains(first));
  if (!string.IsNullOrWhiteSpace(last))
      searchCriteria.Add(q => q.last.Contains(last));
  //.. around 50 additional criteria
var query = Db.Names.AsQueryable();
if(searchCriteria.Any())
{
    var joinedSearchCriteria = Join(Expression.Or, searchCriteria);
    query = query.Where(joinedSearchCriteria);
}
  return query.ToList();

Answer 3

使用实体框架，是否有一种简单干净的方法将“或”条件添加到动态生成的查询中？

是的，您可以通过简单地依靠一个子句，其中包含一个单个布尔表达式，其或 parts在运行时动态“禁用”或“启用”，因此，避免必须安装linqkit或编写自定义谓词构建器。

参考您的示例：

var isFirstValid = !string.IsNullOrWhiteSpace(first);
var isLastValid = !string.IsNullOrWhiteSpace(last);

var query = db.Names
  .AsQueryable()
  .Where(name =>
    (isFirstValid && name.first.Contains(first)) ||
    (isLastValid && name.last.Contains(last))
  )
  .ToList();

如上所述，我们正在动态切换> -filter表达式基于先前评估的前提的- 零件（例如）（例如isfirstValid）。

例如，如果iSfirstValid不是true，则name.first.contains（first） is 短路，既不会执行也不会影响结果集。此外，EF Core的defaultquerysqlgenerator将进一步优化并减少 内部的布尔表达式在执行之前（例如false＆amp;＆amp;＆amp; x || true＆amp;＆amp; y y || ＆amp;＆amp; z 可以通过简单的静态分析简单地 ）。

请注意：如果这些前提都不是true，那么结果集将是空的 - 我认为这是您的情况下的所需行为。但是，如果您出于某种原因而不是从iQueryable源中选择所有元素，则可以将最终变量添加到true（例如）中。 。

最后一句话：该技术的缺点是，它迫使您构建一个位于您查询所在的相同方法的“集中”布尔表达式（更准确地说是，其中 查询的一部分）。如果您出于某种原因想将谓词的构建过程分散，并通过查询构建器将其注入参数或将其注入参数，那么您应该最好坚持使用其他答案中建议的谓词构建器。否则，请享受这种简单的技术:)

Answer 4

striplingwarrior的答案，我写了我的linq扩展名来以linq的方式进行这项工作：

https://github.com/flithor/reusablecodes/blob/main/main/efcore/orpredicate.cs

代码（可能不是最新的）：

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

namespace Flithors_ReusableCodes
{
    /// <summary>
    /// Make <see cref="IQueryable{T}"/> support or predicate in linq way
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IQueryOr<T>
    {
        IQueryOr<T> WhereOr(Expression<Func<T, bool>> predicate);
        IQueryable<T> AsQueryable();
    }
    /// <summary>
    /// The extension methods about or predicate
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static class OrPredicate
    {
        /// <summary>
        /// Private or predicate builder
        /// </summary>
        /// <typeparam name="T"></typeparam>
        private class OrPredicateBuilder<T> : IQueryOr<T>
        {
            List<Expression<Func<T, bool>>> predicates = new List<Expression<Func<T, bool>>>();
            IQueryable<T> sourceQueryable;

            #region private methods
            internal OrPredicateBuilder(IQueryable<T> sourceQueryable) => this.sourceQueryable = sourceQueryable;
            private OrPredicate(IQueryable<T> sourceQueryable, IEnumerable<Expression<Func<T, bool>>> predicates)
            {
                this.sourceQueryable = sourceQueryable;
                this.predicates.AddRange(predicates);
            }

            //===============================================
            // Code From: https://stackoverflow.com/a/50414456/6859121
            private class ExpressionReplacer : ExpressionVisitor
            {
                private readonly Func<Expression, Expression> replacer;

                public ExpressionReplacer(Func<Expression, Expression> replacer)
                {
                    this.replacer = replacer;
                }

                public override Expression Visit(Expression node)
                {
                    return base.Visit(replacer(node));
                }
            }
            private static TExpression ReplaceParameter<TExpression>(TExpression expr, ParameterExpression toReplace, ParameterExpression replacement) where TExpression : Expression
            {
                var replacer = new ExpressionReplacer(e => e == toReplace ? replacement : e);
                return (TExpression)replacer.Visit(expr);
            }
            private static Expression<Func<TEntity, TReturn>> Join<TEntity, TReturn>(Func<Expression, Expression, BinaryExpression> joiner, IReadOnlyCollection<Expression<Func<TEntity, TReturn>>> expressions)
            {
                if (!expressions.Any())
                {
                    throw new ArgumentException("No expressions were provided");
                }
                var firstExpression = expressions.First();
                if (expressions.Count == 1)
                {
                    return firstExpression;
                }
                var otherExpressions = expressions.Skip(1);
                var firstParameter = firstExpression.Parameters.Single();
                var otherExpressionsWithParameterReplaced = otherExpressions.Select(e => ReplaceParameter(e.Body, e.Parameters.Single(), firstParameter));
                var bodies = new[] { firstExpression.Body }.Concat(otherExpressionsWithParameterReplaced);
                var joinedBodies = bodies.Aggregate(joiner);
                return Expression.Lambda<Func<TEntity, TReturn>>(joinedBodies, firstParameter);
            }
            //================================================
            private Expression<Func<T, bool>> GetExpression() => Join(Expression.Or, predicates);
            #endregion

            #region public methods
            public IQueryOr<T> WhereOr(Expression<Func<T, bool>> predicate)
            {
                return new OrPredicate<T>(sourceQueryable, predicates.Append(predicate));
            }
            public IQueryable<T> AsQueryable()
            {
                if (predicates.Count > 0)
                    return sourceQueryable.Where(GetExpression());
                else // If not any predicates exists, returns orignal query
                    return sourceQueryable;
            }
            #endregion
        }

        /// <summary>
        /// Convert <see cref="IQueryable{T}"/> to <see cref="IQueryOr{T}"/> to make next condition append as or predicate.
        /// Call <see cref="IQueryOr{T}.AsQueryable"/> back to <see cref="IQueryable{T}"/> linq.
        /// </summary>
        /// <typeparam name="TSource"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static IQueryOr<TSource> AsWhereOr<TSource>(this IQueryable<TSource> source)
        {
            return new OrPredicateBuilder<TSource>(source);
        }
    }
}

如何使用：

// IQueryable<ClassA> myQuery = ....;
  
var queryOr = myQuery.AsWhereOr();
// for a condition list ...
// queryOr = queryOr.WhereOr(a => /*some condition*/)

myQuery = queryOr.AsQueryable();

享受！