如何在谓词构建器的帮助下编写 LINQ 查询

Question

我真的很想分享这段代码，因为我认为它很有用。

所以，假设您想以编程方式创建一个 linq 查询。

如果能以可读的格式显示它会非常好，不是吗？

我们可以创建这样的代码：

PredicateBuilder<Document> filter = new PredicateBuilder<Document>();
filter.Add(x => x.IsDeleted == false);
filter.Add(x => x.IsArchive == false);

if (ucSearch.SearchText != "")
    filter.Add(x => x.DocumentName.Contains(ucSearch.SearchText));
repository.GetAll().Where(filter.GetLambda()).ToList();

Answer 1

代码可以在如下帮助类的帮助下实现：

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

namespace Extensions
{
    public class PredicateBuilder<T> : List<Expression<Func<T, bool>>>
    {
        private class ParameterReplacer : ExpressionVisitor
        {
            private readonly ParameterExpression _parameter;
            public ParameterReplacer(ParameterExpression parameter)
            {
                _parameter = parameter;
            }
            protected override Expression VisitParameter(ParameterExpression node)
            {
                return base.VisitParameter(_parameter);
            }
        }
        public Expression<Func<T, bool>> GetLambda()
        {
            if (this.Count > 0)
            {
                var type = Expression.Parameter(typeof(T));
                if (this.Count > 1)
                {
                    BinaryExpression binaryExpression = Expression.MakeBinary(ExpressionType.And,
                        new ParameterReplacer(type).Visit(this.First().Body),
                        new ParameterReplacer(type).Visit(this.Skip(1).First().Body));
                    if (this.Count > 2)
                    {
                        foreach (var ex in this.ToList().Skip(2))
                            binaryExpression = Expression.And(binaryExpression, new ParameterReplacer(type).Visit(ex.Body));
                    }
                    return Expression.Lambda<Func<T, bool>>(binaryExpression, type);
                }
                else
                    return Expression.Lambda<Func<T, bool>>(new ParameterReplacer(type).Visit(this.First().Body), type);
            }
            return null;
        }
        public Func<T, bool> GetPredicate()
        {

            if (this.Count > 0)
            {
                var type = Expression.Parameter(typeof(T));
                if (this.Count > 1)
                {
                    BinaryExpression binaryExpression = Expression.MakeBinary(ExpressionType.And,
                        new ParameterReplacer(type).Visit(this.First().Body),
                        new ParameterReplacer(type).Visit(this.Skip(1).First().Body));
                    if (this.Count > 2)
                    {
                        foreach (var ex in this.ToList().Skip(2))
                            binaryExpression = Expression.And(binaryExpression, new ParameterReplacer(type).Visit(ex.Body));
                    }
                    return Expression.Lambda<Func<T, bool>>(binaryExpression, type).Compile();
                }
                else
                    return Expression.Lambda<Func<T, bool>>(new ParameterReplacer(type).Visit(this.First().Body), type).Compile();
            }
            return null;
        }
    }
}