FilterByItems 方法无法正常工作

Question

我正在构建一个过滤器并使用FilterByItems 方法比较两个数组（一个来自我的前端，一个来自我的数据库）。这一切都通过我前端的覆盖面板进行，用户可以在其中选择不同的人员类型，如成员、工人等等。所以我的问题是现在我有多个不想一起工作的人型悬停。如果我只有一个它可以正常工作，如果我添加第二个它只有在前端列表中具有相同的值时才有效。

正确的情况是： 前端面板一得到了数组中的成员，前端面板二得到了数组中的朋友。 表格显示了在其个人资料中使用这些类型保存的所有人员。

当前和错误的情况是： 面板 1 和面板 2 不使用不同的数组，并且仅在两者具有相同列表时才显示信息，例如都在位置 [0] 上获得成员

一般来说，它看起来像一个单独的查询和查询，并且当第二个面板加入它时，它会完全阻塞。所以这是我的代码（FilterByItems 方法在上面链接）：

//The Filter
//Login
[HttpPost("filter/")]
public async Task<IActionResult> Filter([FromBody] Filter user)
{
    var baseQuery = _context.Personens.AsQueryable();
    //Personentyp 1 Dont works in combination with below
    if (user.personenTypFilter.Length > 0)
        baseQuery = baseQuery.FilterByItems(user.personenTypFilter, (m, k) => m.Personentypzuordnungens.Any(i => i.Personentyp.Bezeichnung.Contains(k)), true);
    ////Personentyp 2
    //if (user.personenTypFilter2.Length > 0)
    //    baseQuery = baseQuery.FilterByItems(user.personenTypFilter2, (m, k) => m.Personentypzuordnungens.Any(i => i.Personentyp.Bezeichnung.Contains(k)), true);
    //---------------------------------
    var result = await (baseQuery.Select(p => new
    {
        personId = p.PersonId,
        nachname = p.Nachname,
        vorname = p.Vorname,
        plz = p.Plz,
        firmBez = p.Firmenbezeichnung,
        ort = p.Ort,
        personentyp = p.Personentypzuordnungens.Select(i => new
        {
            personentypId = i.PersonentypId,
        }),
        aktuellePosition = p.AktuellePosition,
        taetigkeit = p.Tätigkeit,
        kernkompetenzen = p.Kernkompetenzen,
        datenReviewedZeitpunkt = p.DatenReviewedZeitpunkt,
    }).ToListAsync());
    return Ok(result);
}

这就是我在过滤器模型中声明变量的方式：

public string[] personenTypFilter { get; set; }
public string[] personenTypFilter2 { get; set; }

.CombineAnd（来自 cmets）的新问题

baseQuery = baseQuery.Where(
                //Characteristics
                character1Predicate.CombineOr(character1Predicate2).CombineOr(character1Predicate3)
                //Persontypes
                .CombineAnd(personType1Predicate.CombineOr(personType2Predicate).CombineOr(personType3Predicate)));

Answer 1

此函数是FilterByItems 的演变，并添加了额外的公共方法来生成谓词并将它们组合。

您可以通过以下方式在查询中使用新的扩展：

var baseQuery = _context.Personens.AsQueryable();

var predicate1 = baseQuery.GetItemsPredicate(ser.personenTypFilter, (m, k) => m.Personentypzuordnungens.Any(i => i.Personentyp.Bezeichnung.Contains(k)));
var predicate2 = baseQuery.GetItemsPredicate(user.personenTypFilter2, (m, k) => m.Personentypzuordnungens.Any(i => i.Personentyp.Bezeichnung.Contains(k)));

// filter by combined predicates
baseQuery = baseQuery.Where(predicate1.CombineOr(predicate2));

及实施：

public static class QueryableExtensions
{
    public static IQueryable<T> FilterByItems<T, TItem>(this IQueryable<T> query, IEnumerable<TItem> items,
        Expression<Func<T, TItem, bool>> filterPattern, bool isOr = true, bool emptyValue = true)
    {
        var filterLambda = query.GetItemsPredicate(items, filterPattern, isOr, emptyValue);

        return query.Where(filterLambda);
    }

    public static Expression<Func<T, bool>> GetItemsPredicate<T, TItem>(this IEnumerable<T> query, IEnumerable<TItem> items, Expression<Func<T, TItem, bool>> filterPattern, bool isOr = true, bool emptyValue = false)
    {
        Expression predicate = null;
        foreach (var item in items)
        {
            var itemExpr = Expression.Constant(item);
            var itemCondition = ExpressionReplacer.Replace(filterPattern.Body, filterPattern.Parameters[1], itemExpr);
            if (predicate == null)
                predicate = itemCondition;
            else
            {
                predicate = Expression.MakeBinary(isOr ? ExpressionType.OrElse : ExpressionType.AndAlso, predicate,
                    itemCondition);
            }
        }

        predicate ??= Expression.Constant(emptyValue);
        var filterLambda = Expression.Lambda<Func<T, bool>>(predicate, filterPattern.Parameters[0]);
        return filterLambda;
    }

    public static Expression<Func<T, bool>> CombineOr<T>(this Expression<Func<T, bool>> predicate1,
        Expression<Func<T, bool>> predicate2)
    {
        var parameter = predicate1.Parameters[0];
        var body = Expression.OrElse(predicate1.Body, ExpressionReplacer.GetBody(predicate2, parameter));
        return Expression.Lambda<Func<T, bool>>(body, parameter);
    }

    public static Expression<Func<T, bool>> CombineAnd<T>(this Expression<Func<T, bool>> predicate1,
        Expression<Func<T, bool>> predicate2)
    {
        var parameter = predicate1.Parameters[0];
        var body = Expression.AndAlso(predicate1.Body, ExpressionReplacer.GetBody(predicate2, parameter));
        return Expression.Lambda<Func<T, bool>>(body, parameter);
    }

    class ExpressionReplacer : ExpressionVisitor
    {
        readonly IDictionary<Expression, Expression> _replaceMap;

        public ExpressionReplacer(IDictionary<Expression, Expression> replaceMap)
        {
            _replaceMap = replaceMap ?? throw new ArgumentNullException(nameof(replaceMap));
        }

        public override Expression Visit(Expression node)
        {
            if (node != null && _replaceMap.TryGetValue(node, out var replacement))
                return replacement;
            return base.Visit(node);
        }

        public static Expression Replace(Expression expr, Expression toReplace, Expression toExpr)
        {
            return new ExpressionReplacer(new Dictionary<Expression, Expression> { { toReplace, toExpr } }).Visit(expr);
        }

        public static Expression Replace(Expression expr, IDictionary<Expression, Expression> replaceMap)
        {
            return new ExpressionReplacer(replaceMap).Visit(expr);
        }

        public static Expression GetBody(LambdaExpression lambda, params Expression[] toReplace)
        {
            if (lambda.Parameters.Count != toReplace.Length)
                throw new InvalidOperationException();

            return new ExpressionReplacer(Enumerable.Range(0, lambda.Parameters.Count)
                .ToDictionary(i => (Expression)lambda.Parameters[i], i => toReplace[i])).Visit(lambda.Body);
        }
    }
}