如安在 .NET 中构建一个好用的动态查询天生器

媒介

自从.NET Framework 3.5提供了LINQ之后，集合数据查询根本被LINQ统一了。这大幅提高了编写数据查询代码的效率和质量，但是在必要编写动态查询的时候反而很困难，特殊是最常用的where和order by子句，他们的参数是Expression。编写静态查询的时候编译器会主动把代码转换成等价的表达式，而动态查询无法借助编译器完成表达式构建，只能手动拼接。想要正确拼接一个形貌低级代码结构的表达式对开发者的功力提出了较高的要求，哪怕是这方面的高手也容易翻车。
为了简化查询表达式的动态构建，社区出现了很多表达式天生辅助库。其中最知名当属System.Linq.Dynamic.Core和LinqKit。System.Linq.Dynamic.Core利用字符串定义表达式，并在内部转换成Expression，LinqKit则是利用PredicateBuilder把复杂表达式拆分成多个片断的组合。但是他们也存在一些不便之处，System.Linq.Dynamic.Core牺牲了代码的静态检查能力，只有在运行时才知道表达式是否正确。如果把表达式作为允许前端填写的参数，不但必要让前端开发人员多学习一套表达式定义语法，还会产生安全毛病。如果想提前检查表达式的安全性，就必要对字符串进行分析。分析字符串天生表达式会成为一个流行库的原因之一就是分析这个字符串很难，这样一来相当于把外包出去的困难任务又拿回来了。LinqKit则是对前端不友爱，这种类型无法序列化传输，如果想通过前端共同利用，还是必要再想办法写一套转换代码和配套的可序列化数据结构。
这两个库在传输序列化和动态拼接简化方面各有显著优势，也各有显着不足。因此笔者开始思考是否有办法开发一个便于序列化传输，安全性能得到静态检查保证，对于复杂表达式的拼接也能良好支持的表达式天生器。经过多次摸索，终有一些心得，在此分享给大家。
新书宣传

有关新书的更多介绍接待查看《C#与.NET6 开发从入门到实践》上市，作者亲自来打广告了！

虽然本书是基于.NET 6编写的，但是其中大多数内容依然可用，仍旧具有一定的参考代价。
正文

提炼根本概念

在安全的前提下提高灵活性

想要保证构建的查询安全性，势必要限制能够查询的属性，最好能让天生器中只出现可以查询的属性。为了避免底层属性改名导致查询出错，或是隐藏代码中的属性名，袒露给天生器的名称应该和真实属性名解耦，两者能独立调解。对于查询器中可能出现的特殊自定义条件提供自定义扩展点。最好支持静态编译检查和基于主动重构的主动代码调解。

1. /// <summary>
2. /// 查询条件构造器接口
3. /// </summary>
4. public interface IFilterPredicateBuilder<T>
5. {
6.     /// <summary>
7.     /// 获取查询条件
8.     /// </summary>
9.     /// <returns>生成的查询条件</returns>
10.     Expression<Func<T, bool>>? GetWherePredicate();
11. }

复制代码

基于以上假设，笔者提炼出了这个根本接口，用于天生器表示支持天生谓词表达式。接口没有任何额外内容以允许最大程度的自定义扩展。
为复杂的嵌套查询提供支持

一个完备的表达式天生一定会面对嵌套对象属性的环境，这其中的问题在于，对象类型无穷无尽，雷同类型的对象也可能出现在各种地方。怎样访问到必要的对象属性并应用筛选条件就是一个必要仔细考虑的问题。在笔者看来，这个问题可以分解为两个子问题，访问属性和应用条件。将这两个部分分离开，条件就可以只针对最终类型开发，属性的访问则交由外部决定。这样一来，针对某种类型开发的条件就可以在任何地方的属性上利用。

1. /// <summary>
2. /// 可组合的查询条件构造器接口
3. /// </summary>
4. public interface IComposableFilterPredicateBuilder<T>
5. {
6.     /// <summary>
7.     /// 获取查询条件，并把条件应用到<typeparamref name="TOwner"/>类型的对象所拥有的<typeparamref name="T"/>类型的成员上。
8.     /// </summary>
9.     /// <typeparam name="TOwner">拥有<typeparamref name="T"/>类型的成员的类型</typeparam>
10.     /// <param name="memberAccesser">成员访问器</param>
11.     /// <returns>已应用到成员的查询条件</returns>
12.     Expression<Func<TOwner, bool>>? GetWherePredicate<TOwner>(Expression<Func<TOwner, T>> memberAccesser);
13. }
15. /// <summary>
16. /// 值类型可组合的查询条件构造器接口
17. /// </summary>
18. public interface IStructComposableFilterPredicateBuilder<T> : IComposableFilterPredicateBuilder<T>
19.     where T : struct
20. {
21.     /// <summary>
22.     /// 获取查询条件，并把条件应用到<typeparamref name="TOwner"/>类型的对象所拥有的<typeparamref name="T"/>类型的成员上。
23.     /// </summary>
24.     /// <typeparam name="TOwner">拥有<typeparamref name="T"/>类型的成员的类型</typeparam>
25.     /// <param name="memberAccesser">成员访问器</param>
26.     /// <returns>已应用到成员的查询条件</returns>
27.     Expression<Func<TOwner, bool>>? GetWherePredicate<TOwner>(Expression<Func<TOwner, T?>> memberAccesser);
28. }

复制代码

基于以上假设，可以再次提炼出一个接口。通过参数由外部决定属性怎样访问，并返回最终拼合条件。值类型必要特殊处理。
为集合类型的查询提供支持

偶然要查询的属性可能是集合类型，这种查询和平凡的单值查询有区别，必要单独处理。

1. /// <summary>
2. /// 集合可组合的查询条件构造器接口
3. /// </summary>
4. public interface ICollectionComposableFilterPredicateBuilder<T>
5. {
6.     /// <summary>
7.     /// 获取查询条件，并把条件应用到<typeparamref name="TOwner"/>类型的对象所拥有的<typeparamref name="T"/>类型的集合的成员上。
8.     /// </summary>
9.     /// <typeparam name="TOwner">拥有<typeparamref name="T"/>类型的集合的成员的类型</typeparam>
10.     /// <param name="memberAccesser">成员访问器</param>
11.     /// <returns>已应用到成员的查询条件</returns>
12.     Expression<Func<TOwner, bool>>? GetWherePredicate<TOwner>(Expression<Func<TOwner, IEnumerable<T>>> memberAccesser);
13. }

复制代码

这表示专门用于集合类型的查询，IQueryable实现了IEnumerable，不必要单独定义。
条件反转

一键支持条件反转是个非常有效的功能，如果一个条件有多个子条件，且条件之间混淆了各种加了括号的且或非连接，想要正确反转这样的条件非常困难。

1. /// <summary>
2. /// 可反转条件接口
3. /// </summary>
4. public interface IPredicateReversible
5. {
6.     /// <summary>
7.     /// 是否反转条件
8.     /// </summary>
9.     bool Reverse { get; }
10. }

复制代码

利用一个bool标记反转条件，由查询天生器主动处理反转是公道的选择。
序列化传输支持

到此为止，一个完备的表达式天生器所需的根本接口就提炼完成了。但是这些接口所表达的概念并不支持序列化传输，接下来就要解决这问题。
序列化传输查询条件意味着要分离出条件中可以序列化的部分。比方：Foo.Bar > 1，此处必要传输的部分是属性，比较方式，比较参数。属性的话由于必要支持静态检查，必要单独处理。至于比较方式，办法比较多，笔者选择利用枚举来表达。关键字一样平常是各种基础类型，应该自然支持序列化。

1. /// <summary>
2. /// 引用类型搜索关键字接口
3. /// </summary>
4. /// <typeparam name="T">关键字类型</typeparam>
5. public interface ISearchFilterClassKey<T> where T : class
6. {
7.     /// <summary>
8.     /// 搜索关键字
9.     /// </summary>
10.     ImmutableList<T?> Keys { get; }
11. }
13. /// <summary>
14. /// 值类型搜索关键字接口
15. /// </summary>
16. /// <typeparam name="T">关键字类型</typeparam>
17. public interface ISearchFilterStructKey<T> where T : struct
18. {
19.     /// <summary>
20.     /// 搜索关键字
21.     /// </summary>
22.     ImmutableList<T?> Keys { get; }
23. }
25. /// <summary>
26. /// 搜索操作符接口
27. /// </summary>
28. /// <typeparam name="TOperator"></typeparam>
29. public interface ISearchFilterOperator<TOperator> where TOperator : struct, Enum
30. {
31.     /// <summary>
32.     /// 搜索操作符
33.     /// </summary>
34.     TOperator Operator { get; }
35. }

复制代码

基于以上假设，可以提炼出以上接口。
为概念接口提供实现

这些接口表达了查询天生器所需的各种概念，但是让开发者自行实现并不是好主意，这些接口对于开发者来说应该是用做泛型束缚的。笔者势必要为此提供一套最常见情形的实现。

1. /// <summary>
2. /// 查询构造器基类
3. /// </summary>
4. /// <typeparam name="T">查询的数据类型</typeparam>
5. /// <param name="CombineType">条件谓词组合方式。Json属性名用 combine 减少字数。</param>
6. /// <inheritdoc cref="IFilterPredicateBuilder{T}"/>
7. public abstract record QueryBuilderBase<T>(
8.     [EnumDataType(typeof(PredicateCombineKind))]
9.     PredicateCombineKind? CombineType = PredicateCombineKind.And)
10.     : IFilterPredicateBuilder<T>, IComposableFilterPredicateBuilder<T>
11. {
12.     /// <inheritdoc/>
13.     public Expression<Func<T, bool>>? GetWherePredicate()
14.     {
15.         var where = BuildWherePredicate();
16.         if (this is IPredicateReversible reversible) where = reversible.ApplyReversiblePredicate(where);
17.         return where;
18.     }
20.     /// <summary>
21.     /// 构造查询条件
22.     /// </summary>
23.     /// <returns>获得的查询条件</returns>
24.     /// <remarks>
25.     /// 派生类重写时请只负责构造自身的条件，
26.     /// 最后使用<see cref="CombinePredicates"/>合并来自基类的条件后再返回。
27.     /// 不要在这里进行条件反转。
28.     /// </remarks>
29.     protected virtual Expression<Func<T, bool>>? BuildWherePredicate()
30.     {
31.         return null;
32.     }
34.     /// <summary>
35.     /// 组合查询条件
36.     /// </summary>
37.     /// <param name="predicates">待组合的子条件</param>
38.     /// <returns></returns>
39.     /// <exception cref="NotSupportedException"></exception>
40.     protected Expression<Func<T, bool>>? CombinePredicates(IEnumerable<Expression<Func<T, bool>>>? predicates)
41.     {
42.         var predicate = predicates?.FirstOrDefault();
43.         if (predicates?.Any() is true)
44.         {
45.             predicate = CombineType switch
46.             {
47.                 PredicateCombineKind.And => predicates?.AndAlsoAll(),
48.                 PredicateCombineKind.Or => predicates?.OrElseAll(),
49.                 _ => throw new NotSupportedException(CombineType.ToString()),
50.             };
51.         }
53.         return predicate;
54.     }
56.     /// <inheritdoc/>
57.     /// <exception cref="ArgumentNullException"></exception>
58.     public Expression<Func<TOwner, bool>>? GetWherePredicate<TOwner>(Expression<Func<TOwner, T>> memberAccesser)
59.     {
60.         ArgumentNullException.ThrowIfNull(memberAccesser);
62.         var where = GetWherePredicate();
63.         if (where is null) return null;
65.         MemberReplaceExpressionVisitor visitor = new();
66.         var result = visitor.ReplaceMember(memberAccesser, where);
68.         return result;
69.     }
71.     /// <summary>
72.     /// 成员访问表达式替换访问器
73.     /// </summary>
74.     private sealed class MemberReplaceExpressionVisitor : ExpressionVisitor
75.     {
76.         private readonly Lock _lock = new();
78.         private volatile bool _calledFromReplaceMember = false;
79.         private LambdaExpression? _memberAccesser;
81.         /// <summary>
82.         /// 把指定表达式的成员访问替换为新的成员访问。
83.         /// </summary>
84.         /// <typeparam name="TOwner">拥有<typeparamref name="TMember"/>类型的成员的类型</typeparam>
85.         /// <typeparam name="TMember">用于替换成员访问的类型</typeparam>
86.         /// <typeparam name="TResult">返回值类型</typeparam>
87.         /// <param name="memberAccessor">替换用的新成员访问表达式。</param>
88.         /// <param name="resultAccessor">要替换成员访问的表达式。</param>
89.         /// <returns>已替换成员访问的表达式。</returns>
90.         /// <exception cref="ArgumentNullException"></exception>
91.         public Expression<Func<TOwner, TResult>> ReplaceMember<TOwner, TMember, TResult>(
92.             Expression<Func<TOwner, TMember>> memberAccessor,
93.             Expression<Func<TMember, TResult>> resultAccessor)
94.         {
95.             ArgumentNullException.ThrowIfNull(resultAccessor);
96.             ArgumentNullException.ThrowIfNull(memberAccessor);
98.             lock (_lock)
99.             {
100.                 try
101.                 {
102.                     _calledFromReplaceMember = true;
103.                     _memberAccesser = memberAccessor;
105.                     var newLambda = (LambdaExpression)Visit(resultAccessor);
107.                     return Expression.Lambda<Func<TOwner, TResult>>(newLambda.Body, memberAccessor.Parameters);
108.                 }
109.                 catch
110.                 {
111.                     throw;
112.                 }
113.                 finally
114.                 {
115.                     _calledFromReplaceMember = false;
116.                     _memberAccesser = null;
117.                 }
118.             }
119.         }
121.         /// <inheritdoc/>
122.         [return: NotNullIfNotNull(nameof(node))]
123.         public override Expression? Visit(Expression? node)
124.         {
125.             if (!_calledFromReplaceMember) throw new InvalidOperationException($"Don't call directly, call {nameof(ReplaceMember)} instead.");
127.             return base.Visit(node);
128.         }
130.         /// <inheritdoc/>
131.         protected override Expression VisitMember(MemberExpression node)
132.         {
133.             if (node.Expression is ParameterExpression)
134.             {
135.                 return Expression.PropertyOrField(_memberAccesser!.Body, node.Member.Name);
136.             }
138.             return base.VisitMember(node);
139.         }
140.     }
141. }
143. /// <summary>
144. /// 条件谓词组合方式
145. /// </summary>
146. public enum PredicateCombineKind
147. {
148.     /// <summary>
149.     /// 且
150.     /// </summary>
151.     And = 1,
153.     /// <summary>
154.     /// 或
155.     /// </summary>
156.     Or = 2
157. }
159. /// <summary>
160. /// 可反转谓词接口扩展
161. /// </summary>
162. public static class PredicateReversibleExtensions
163. {
164.     /// <summary>
165.     /// 应用可反转的谓词
166.     /// </summary>
167.     /// <typeparam name="T">谓词表达式的参数类型</typeparam>
168.     /// <param name="reversible">可反转谓词接口的实例</param>
169.     /// <param name="predicate">谓词表达式</param>
170.     /// <returns></returns>
171.     public static Expression<Func<T, bool>>? ApplyReversiblePredicate<T>(
172.         this IPredicateReversible reversible,
173.         Expression<Func<T, bool>>? predicate)
174.     {
175.         return !reversible.Reverse ? predicate : predicate?.Not();
176.     }
177. }

复制代码

在接口的GetWherePredicate()方法之外，增加一个内部的BuildWherePredicate()方法，把天生根本条件和反转条件隔离开并统一处理，确保反转条件只会在末了进行一次。
实现通用的根本类型过滤器表达式

定义操纵类型

1. /// <summary>
2. /// 基本搜索操作
3. /// </summary>
4. public enum BaseSearchOperator : uint
5. {
6.     /// <summary>
7.     /// 等于
8.     /// </summary>
9.     Equal = 1 << 0,
11.     /// <summary>
12.     /// 是候选项之一
13.     /// </summary>
14.     In = 1 << 1,
15. }
17. /// <summary>
18. /// 字符串搜索操作
19. /// </summary>
20. public enum StringSearchOperator : uint
21. {
22.     /// <summary>
23.     /// 等于
24.     /// </summary>
25.     Equal = 1 << 0,
27.     /// <summary>
28.     /// 是候选项之一
29.     /// </summary>
30.     In = 1 << 1,
32.     /// <summary>
33.     /// 包含
34.     /// </summary>
35.     Contains = 1 << 2,
37.     /// <summary>
38.     /// 包含全部候选项
39.     /// </summary>
40.     EqualContains = Equal | Contains,
42.     /// <summary>
43.     /// 包含候选项之一
44.     /// </summary>
45.     InContains = In | Contains,
47.     /// <summary>
48.     /// 开头是
49.     /// </summary>
50.     StartsWith = 1 << 3,
52.     /// <summary>
53.     /// 开头是候选项之一
54.     /// </summary>
55.     InStartsWith = In | StartsWith,
57.     /// <summary>
58.     /// 结尾是
59.     /// </summary>
60.     EndsWith = 1 << 4,
62.     /// <summary>
63.     /// 结尾是候选项之一
64.     /// </summary>
65.     InEndsWith = In | EndsWith,
66. }
68. /// <summary>
69. /// 可排序数字搜索操作
70. /// </summary>
71. public enum ComparableNumberSearchOperator : uint
72. {
73.     /// <summary>
74.     /// 等于
75.     /// </summary>
76.     Equal = 1 << 0,
78.     /// <summary>
79.     /// 是候选项之一
80.     /// </summary>
81.     In = 1 << 1,
83.     /// <summary>
84.     /// 小于
85.     /// </summary>
86.     LessThan = 1 << 2,
88.     /// <summary>
89.     /// 小于等于
90.     /// </summary>
91.     LessThanOrEqual = LessThan | Equal,
93.     /// <summary>
94.     /// 大于
95.     /// </summary>
96.     GreaterThan = 1 << 3,
98.     /// <summary>
99.     /// 大于等于
100.     /// </summary>
101.     GreaterThanOrEqual = GreaterThan | Equal,
103.     /// <summary>
104.     /// 介于两个值之间，但不包含两边的边界值
105.     /// </summary>
106.     BetweenOpen = 1 << 4,
108.     /// <summary>
109.     /// 是多组介于两个值之间，但不包含两边的边界值的候选区间之一
110.     /// </summary>
111.     InBetweenOpen = In | BetweenOpen,
113.     /// <summary>
114.     /// 介于两个值之间，包含左边界值，但不包含右边界值
115.     /// </summary>
116.     BetweenLeftClosed = 1 << 5,
118.     /// <summary>
119.     /// 是多组介于两个值之间，包含左边界值，但不包含右边界值的候选区间之一
120.     /// </summary>
121.     InBetweenLeftClosed = In | BetweenLeftClosed,
123.     /// <summary>
124.     /// 介于两个值之间，包含右边界值，但不包含左边界值
125.     /// </summary>
126.     BetweenRightClosed = 1 << 6,
128.     /// <summary>
129.     /// 是多组介于两个值之间，包含右边界值，但不包含左边界值的候选区间之一
130.     /// </summary>
131.     InBetweenRightClosed = In | BetweenRightClosed,
133.     /// <summary>
134.     /// 介于两个值之间，同时包含两边的边界值
135.     /// </summary>
136.     BetweenClosed = BetweenOpen | BetweenLeftClosed | BetweenRightClosed,
138.     /// <summary>
139.     /// 是多组介于两个值之间，同时包含两边的边界值的候选区间之一
140.     /// </summary>
141.     InBetweenClosed = In | BetweenClosed,
142. }

复制代码

此处展示了一部分基础数据类型的过滤器定义。如果将来有自定义根本类型也可以照葫芦画瓢。
集合类型属性的实现

1. /// <summary>
2. /// 值类型基本搜索过滤器
3. /// </summary>
4. /// <typeparam name="T">要搜索的值类型</typeparam>
5. public record StructSearchFilter<T>
6.     : ISearchFilterStructKey<T>
7.     , ISearchFilterOperator<BaseSearchOperator>
8.     , IStructComposableFilterPredicateBuilder<T>
9.     , IPredicateReversible
10.     where T : struct
11. {
12.     private static readonly Type _baseType = typeof(T);
13.     private static readonly Type _nullableType = typeof(T?);
15.     private static readonly MethodInfo _enumerableContains = typeof(Enumerable)
16.         .GetMethods()
17.         .Where(static m => m.Name is nameof(Enumerable.Contains))
18.         .Single(static m => m.GetParameters().Length is 2)
19.         .MakeGenericMethod([_baseType]);
21.     private static readonly MethodInfo _enumerableNullableContains = typeof(Enumerable)
22.         .GetMethods()
23.         .Where(static m => m.Name is nameof(Enumerable.Contains))
24.         .Single(static m => m.GetParameters().Length is 2)
25.         .MakeGenericMethod([_nullableType]);
27.     /// <summary>
28.     /// 初始化一个新实例
29.     /// </summary>
30.     /// <param name="keys">搜索关键字</param>
31.     /// <param name="operator">搜索操作符</param>
32.     /// <param name="reverse">是否反转条件</param>
33.     /// <exception cref="ArgumentException"></exception>
34.     /// <exception cref="InvalidEnumArgumentException"></exception>
35.     public StructSearchFilter(
36.         ImmutableList<T?> keys,
37.         [EnumDataType(typeof(BaseSearchOperator))]
38.         BaseSearchOperator @operator = BaseSearchOperator.Equal,
39.         bool reverse = false)
40.     {
41.         ArgumentNullException.ThrowIfNull(nameof(keys));
42.         if (keys is null or { Count: 0 }) throw new ArgumentException("不能是空集。", nameof(keys));
43.         if (!Enum.IsDefined(@operator)) throw new InvalidEnumArgumentException(nameof(@operator), (int)@operator, @operator.GetType());
45.         if (@operator is BaseSearchOperator.In && keys is null or { Count: < 2 })
46.         {
47.             throw new ArgumentException($"当 {nameof(@operator)} 的值为 {@operator} 时必须设置多个元素。", nameof(keys));
48.         }
49.         else if (@operator is not BaseSearchOperator.In && keys is { Count: > 1 })
50.         {
51.             throw new ArgumentException($"当 {nameof(@operator)} 的值为 {@operator} 时必须设置一个元素。", nameof(keys));
52.         }
53.         else if (@operator is not (BaseSearchOperator.In or BaseSearchOperator.Equal) && keys.Any(static n => Equals(n, null)))
54.         {
55.             throw new ArgumentException($"当 {nameof(@operator)} 的值为 {@operator} 时元素的值不能为空。", nameof(keys));
56.         }
58.         Keys = keys;
59.         Operator = @operator;
60.         Reverse = reverse;
61.     }
63.     /// <inheritdoc/>
64.     public virtual ImmutableList<T?> Keys { get; }
66.     /// <inheritdoc/>
67.     public virtual BaseSearchOperator Operator { get; }
69.     /// <inheritdoc/>
70.     public virtual bool Reverse { get; }
72.     /// <inheritdoc/>
73.     /// <exception cref="InvalidOperationException"></exception>
74.     /// <exception cref="InvalidDataException"></exception>
75.     public Expression<Func<TOwner, bool>> GetWherePredicate<TOwner>(Expression<Func<TOwner, T>> memberAccessor)
76.     {
77.         if (Keys.Any(static n => n is null)) throw new InvalidOperationException("不能使用值为空的元素搜索值不能为空的成员。");
79.         Expression newBody = Operator switch
80.         {
81.             BaseSearchOperator.Equal => Expression.Equal(memberAccessor.Body, Expression.Constant(Keys.First(), _baseType)),
82.             BaseSearchOperator.In => Expression.Call(null, _enumerableContains, [Expression.Constant(Keys.Cast<T>().ToList(), typeof(IEnumerable<T>)), memberAccessor.Body]),
83.             _ => throw new InvalidDataException(nameof(ComparableNumberSearchOperator))
84.         };
86.         if (Reverse) newBody = Expression.Not(newBody);
88.         return Expression.Lambda<Func<TOwner, bool>>(newBody, memberAccessor.Parameters);
89.     }
91.     /// <inheritdoc/>
92.     /// <exception cref="InvalidOperationException"></exception>
93.     /// <exception cref="InvalidDataException"></exception>
94.     public Expression<Func<TOwner, bool>> GetWherePredicate<TOwner>(Expression<Func<TOwner, T?>> memberAccessor)
95.     {
96.         Expression newBody = Operator switch
97.         {
98.             BaseSearchOperator.Equal => Expression.Equal(memberAccessor.Body, Expression.Constant(Keys.First(), _nullableType)),
99.             BaseSearchOperator.In => Expression.Call(null, _enumerableNullableContains, [Expression.Constant(Keys, typeof(IEnumerable<T?>)), memberAccessor.Body]),
100.             _ => throw new InvalidDataException(nameof(ComparableNumberSearchOperator))
101.         };
103.         if (Reverse) newBody = Expression.Not(newBody);
105.         return Expression.Lambda<Func<TOwner, bool>>(newBody, memberAccessor.Parameters);
106.     }
107. }
109. /// <summary>
110. /// 布尔搜索过滤器
111. /// </summary>
112. public record BoolSearchFilter : StructSearchFilter<bool>
113. {
114.     /// <inheritdoc/>
115.     public BoolSearchFilter(
116.         ImmutableList<bool?> keys,
117.         [EnumDataType(typeof(BaseSearchOperator))]
118.         BaseSearchOperator @operator = BaseSearchOperator.Equal,
119.         bool reversePredicate = false) : base(keys, @operator, reversePredicate)
120.     {
121.     }
122. }
124. /// <summary>
125. /// 可排序数字搜索过滤器
126. /// </summary>
127. /// <typeparam name="TNumber">数字的类型</typeparam>
128. public record NumberSearchFilter<TNumber>
129.     : IStructComposableFilterPredicateBuilder<TNumber>
130.     , ISearchFilterStructKey<TNumber>
131.     , ISearchFilterOperator<ComparableNumberSearchOperator>
132.     , IPredicateReversible
133.     where TNumber : struct, IComparisonOperators<TNumber, TNumber, bool>
134. {
135.     /// <summary>
136.     /// 初始化一个新实例
137.     /// </summary>
138.     /// <param name="keys">搜索关键字</param>
139.     /// <param name="operator">搜索操作符</param>
140.     /// <param name="reverse">是否反转条件</param>
141.     /// <exception cref="ArgumentException"></exception>
142.     /// <exception cref="InvalidEnumArgumentException"></exception>
143.     public NumberSearchFilter(
144.         ImmutableList<TNumber?> keys,
145.         [EnumDataType(typeof(ComparableNumberSearchOperator))]
146.         ComparableNumberSearchOperator @operator = ComparableNumberSearchOperator.Equal,
147.         bool reverse = false)
148.     {
149.         ArgumentNullException.ThrowIfNull(nameof(keys));
150.         if (keys is null or { Count: 0 }) throw new ArgumentException("不能是空集。", nameof(keys));
151.         if (!Enum.IsDefined(@operator)) throw new InvalidEnumArgumentException(nameof(@operator), (int)@operator, @operator.GetType());
153.         string? message = GetKeysCheckMessage(keys, @operator);
154.         if (message is not null) throw new ArgumentException(message, nameof(keys));
156.         Keys = keys;
157.         Operator = @operator;
158.         Reverse = reverse;
159.     }
161.     /// <inheritdoc/>
162.     public virtual ImmutableList<TNumber?> Keys { get; }
164.     /// <inheritdoc/>
165.     public virtual ComparableNumberSearchOperator Operator { get; }
167.     /// <inheritdoc/>
168.     public virtual bool Reverse { get; }
170.     /// <inheritdoc/>
171.     /// <exception cref="InvalidOperationException"></exception>
172.     /// <exception cref="InvalidDataException"></exception>
173.     public Expression<Func<TOwner, bool>> GetWherePredicate<TOwner>(Expression<Func<TOwner, TNumber>> memberAccessor)
174.     {
175.         NullKeyCheck(Keys);
177.         var where = GetWherePredicateExtension(Keys, Operator, memberAccessor);
178.         if (Reverse) where = where.Not();
179.         return where;
180.     }
182.     /// <inheritdoc/>
183.     /// <exception cref="InvalidOperationException"></exception>
184.     /// <exception cref="InvalidDataException"></exception>
185.     public Expression<Func<TOwner, bool>> GetWherePredicate<TOwner>(Expression<Func<TOwner, TNumber?>> memberAccessor)
186.     {
187.         var where = GetWherePredicateExtension(Keys, Operator, memberAccessor);
188.         if (Reverse) where = where.Not();
189.         return where;
190.     }
191. }
193. /// <summary>
194. /// 字符串搜索过滤器
195. /// </summary>
196. public record StringSearchFilter
197.     : IComposableFilterPredicateBuilder<string>
198.     , ISearchFilterOperator<StringSearchOperator>
199.     , ISearchFilterClassKey<string>
200.     , IPredicateReversible
201. {
202.     private static readonly MethodInfo _contains = typeof(string)
203.         .GetMethod(
204.             nameof(string.Contains),
205.             BindingFlags.Public | BindingFlags.Instance,
206.             [typeof(string)]
207.         )!;
209.     private static readonly MethodInfo _startsWith = typeof(string)
210.         .GetMethod(
211.             nameof(string.StartsWith),
212.             BindingFlags.Public | BindingFlags.Instance,
213.             [typeof(string)]
214.         )!;
216.     private static readonly MethodInfo _endsWith = typeof(string)
217.         .GetMethod(
218.             nameof(string.EndsWith),
219.             BindingFlags.Public | BindingFlags.Instance,
220.             [typeof(string)]
221.         )!;
223.     private static readonly MethodInfo _equals = typeof(string)
224.         .GetMethod(
225.             nameof(string.Equals),
226.             BindingFlags.Public | BindingFlags.Instance,
227.             [typeof(string)]
228.         )!;
230.     private static readonly MethodInfo _enumerableContains = typeof(Enumerable)
231.         .GetMethods()
232.         .Where(static m => m.Name is nameof(Enumerable.Contains))
233.         .Single(static m => m.GetParameters().Length is 2)
234.         .MakeGenericMethod([typeof(string)]);
236.     /// <summary>
237.     /// 初始化一个新实例
238.     /// </summary>
239.     /// <param name="keys">搜索关键字</param>
240.     /// <param name="operator">搜索操作符</param>
241.     /// <param name="reverse">是否反转条件</param>
242.     /// <exception cref="ArgumentException"></exception>
243.     /// <exception cref="InvalidEnumArgumentException"></exception>
244.     public StringSearchFilter(
245.         ImmutableList<string?> keys,
246.         [EnumDataType(typeof(StringSearchOperator))]
247.         StringSearchOperator @operator = StringSearchOperator.Contains,
248.         bool reverse = false)
249.     {
250.         ArgumentNullException.ThrowIfNull(nameof(keys));
251.         if (keys is null or { Count: 0 }) throw new ArgumentException("不能是空集。", nameof(keys));
252.         if (!Enum.IsDefined(@operator)) throw new InvalidEnumArgumentException(nameof(@operator), (int)@operator, @operator.GetType());
254.         string? exceptionHint = null;
255.         switch (@operator)
256.         {
257.             case StringSearchOperator.Equal:
258.                 if (keys is { Count: > 1 })
259.                 {
260.                     exceptionHint = $"必须设置一个元素。";
261.                     goto default;
262.                 }
263.                 break;
264.             case StringSearchOperator.In:
265.                 if (keys is { Count: < 2 })
266.                 {
267.                     exceptionHint = $"必须设置多个元素。";
268.                     goto default;
269.                 }
270.                 break;
271.             case StringSearchOperator.Contains:
272.                 goto case StringSearchOperator.Equal;
273.             case StringSearchOperator.EqualContains:
274.                 if (keys is { Count: < 2 })
275.                 {
276.                     exceptionHint = $"必须设置多个元素。";
277.                     goto default;
278.                 }
279.                 else if (keys.Any(static key => key is null))
280.                 {
281.                     exceptionHint = $"元素不能为空。";
282.                     goto default;
283.                 }
284.                 break;
285.             case StringSearchOperator.InContains:
286.                 goto case StringSearchOperator.EqualContains;
287.             case StringSearchOperator.StartsWith:
288.                 if (keys is { Count: > 2 })
289.                 {
290.                     exceptionHint = $"必须设置一个元素。";
291.                     goto default;
292.                 }
293.                 else if (keys.Any(static key => key is null))
294.                 {
295.                     exceptionHint = $"元素不能为空。";
296.                     goto default;
297.                 }
298.                 break;
299.             case StringSearchOperator.InStartsWith:
300.                 goto case StringSearchOperator.EqualContains;
301.             case StringSearchOperator.EndsWith:
302.                 goto case StringSearchOperator.StartsWith;
303.             case StringSearchOperator.InEndsWith:
304.                 goto case StringSearchOperator.EqualContains;
305.             default:
306.                 exceptionHint ??= "的元素数量错误。";
307.                 throw new ArgumentException($"当 {nameof(@operator)} 的值为 {@operator} 时{exceptionHint}", nameof(keys));
308.         };
310.         Keys = keys;
311.         Operator = @operator;
312.         Reverse = reverse;
313.     }
315.     /// <inheritdoc/>
316.     public virtual ImmutableList<string?> Keys { get; }
318.     /// <inheritdoc/>
319.     public virtual StringSearchOperator Operator { get; }
321.     /// <inheritdoc/>
322.     public virtual bool Reverse { get; }
324.     /// <inheritdoc/>
325.     /// <exception cref="InvalidDataException"></exception>
326.     public Expression<Func<TOwner, bool>> GetWherePredicate<TOwner>(Expression<Func<TOwner, string>> memberAccessor)
327.     {
328.         (MethodInfo method, object? value, Type type) = Operator switch
329.         {
330.             StringSearchOperator.Equal => (_equals, (object?)Keys![0], typeof(string)),
331.             StringSearchOperator.In => (_enumerableContains, Keys, typeof(IEnumerable<string?>)),
332.             StringSearchOperator.Contains => (_contains, Keys![0], typeof(string)),
333.             StringSearchOperator.EqualContains => (_contains, Keys, typeof(string)),
334.             StringSearchOperator.InContains => (_contains, Keys, typeof(string)),
335.             StringSearchOperator.StartsWith => (_startsWith, Keys![0], typeof(string)),
336.             StringSearchOperator.InStartsWith => (_startsWith, Keys, typeof(string)),
337.             StringSearchOperator.EndsWith => (_endsWith, Keys![0], typeof(string)),
338.             StringSearchOperator.InEndsWith => (_endsWith, Keys, typeof(string)),
339.             _ => throw new InvalidDataException(nameof(StringSearchOperator))
340.         };
342.         Expression newBody;
343.         switch (Operator)
344.         {
345.             case StringSearchOperator.Equal:
346.                 newBody = Expression.Call(memberAccessor.Body, method, Expression.Constant(value, type));
347.                 break;
348.             case StringSearchOperator.In:
349.                 newBody = Expression.Call(null, method, [Expression.Constant(value, type), memberAccessor.Body]);
350.                 break;
351.             case StringSearchOperator.Contains:
352.                 goto case StringSearchOperator.Equal;
353.             case StringSearchOperator.EqualContains:
354.                 newBody = CombineIn((IReadOnlyList<string?>)value!, memberAccessor.Body, method, type, PredicateCombineKind.And);
355.                 break;
356.             case StringSearchOperator.InContains:
357.                 newBody = CombineIn((IReadOnlyList<string?>)value!, memberAccessor.Body, method, type, PredicateCombineKind.Or);
358.                 break;
359.             case StringSearchOperator.StartsWith:
360.                 goto case StringSearchOperator.Equal;
361.             case StringSearchOperator.InStartsWith:
362.                 newBody = CombineIn((IReadOnlyList<string?>)value!, memberAccessor.Body, method, type, PredicateCombineKind.Or);
363.                 break;
364.             case StringSearchOperator.EndsWith:
365.                 goto case StringSearchOperator.Equal;
366.             case StringSearchOperator.InEndsWith:
367.                 goto case StringSearchOperator.InStartsWith;
368.             default:
369.                 throw new InvalidDataException(nameof(StringSearchOperator));
370.         }
372.         if (Reverse) newBody = Expression.Not(newBody);
374.         return Expression.Lambda<Func<TOwner, bool>>(newBody, memberAccessor.Parameters);
376.         static Expression CombineIn(IReadOnlyList<string?> keys, Expression instance, MethodInfo method, Type type, PredicateCombineKind combineKind)
377.         {
378.             Expression expr = Expression.Call(instance, method, Expression.Constant(keys[0], type));
380.             foreach (var key in keys.Skip(1))
381.             {
382.                 expr = combineKind switch
383.                 {
384.                     PredicateCombineKind.And => Expression.AndAlso(expr, Expression.Call(instance, method, Expression.Constant(key, type))),
385.                     PredicateCombineKind.Or => Expression.OrElse(expr, Expression.Call(instance, method, Expression.Constant(key, type))),
386.                     _ => throw new NotImplementedException(),
387.                 };
388.             }
390.             return expr;
391.         }
392.     }
393. }

复制代码

对于集合类型的属性，笔者实现了计数和比例比较，用于筛选符合条件的元素数量或占比是否符合条件。如果必要，各种聚合条件也应该可以实现，此处不再枚举。TryUseAnyCall()方法对计数条件实验利用Any()更换Count()，比方Count > 0等价于Any()，这可以在EF Core中天生更高效的SQL（据说EF Core准备在内部添加这个优化）。
辅助类型

1. /// <summary>
2. /// 复杂类型的集合属性搜索过滤器
3. /// </summary>
4. /// <typeparam name="TQueryBuilder">要搜索的集合元素类型的查询类型</typeparam>
5. /// <typeparam name="T">要搜索的元素类型</typeparam>
6. public record CollectionMemberSearchFilter<TQueryBuilder, T>
7.     : ICollectionComposableFilterPredicateBuilder<T>
8.     , IPredicateReversible
9.     where TQueryBuilder : IFilterPredicateBuilder<T>
10. {
11.     private static readonly MethodInfo _asQueryableOfT = typeof(Queryable)
12.         .GetMethods()
13.         .Single(static m => m.Name is nameof(Queryable.AsQueryable) && m.IsGenericMethod);
15.     private static readonly MethodInfo _queryableWhereOfT = typeof(Queryable)
16.         .GetMethods()
17.         .Single(static m =>
18.         {
19.             return m.Name is nameof(Queryable.Where)
20.                 && m.GetParameters()[1]
21.                     .ParameterType
22.                     .GenericTypeArguments[0]
23.                     .GenericTypeArguments
24.                     .Length is 2;
25.         });
27.     private static readonly MethodInfo _queryableCountOfT = typeof(Queryable)
28.         .GetMethods()
29.         .Single(static m => m.Name is nameof(Queryable.Count) && m.GetParameters().Length is 1);
31.     private static readonly MethodInfo _queryableAnyOfT = typeof(Queryable)
32.         .GetMethods()
33.         .Single(static m => m.Name is nameof(Queryable.Any) && m.GetParameters().Length is 1);
35.     private static readonly MethodInfo _enumerableContains = typeof(Enumerable)
36.         .GetMethods()
37.         .Where(static m => m.Name is nameof(Enumerable.Contains))
38.         .Single(static m => m.GetParameters().Length is 2)
39.         .MakeGenericMethod([typeof(T)]);
41.     /// <summary>
42.     /// 元素的查询
43.     /// </summary>
44.     public TQueryBuilder? Query { get; }
46.     /// <summary>
47.     /// 计数搜索过滤器
48.     /// </summary>
49.     /// <remarks>和<see cref="Percent"/>只能存在一个。</remarks>
50.     public NumberSearchFilter<int>? Count { get; }
52.     /// <summary>
53.     /// 比例搜索过滤器
54.     /// </summary>
55.     /// <remarks>
56.     /// 和<see cref="Count"/>只能存在一个。
57.     /// 如果存在，则<see cref="Query"/>也必须同时存在。
58.     /// </remarks>
59.     public NumberSearchFilter<double>? Percent { get; }
62.     /// <inheritdoc/>
63.     public bool Reverse { get; }
65.     /// <summary>
66.     /// 初始化新的实例
67.     /// </summary>
68.     /// <param name="query">元素的查询</param>
69.     /// <param name="count">计数搜索过滤器</param>
70.     /// <exception cref="ArgumentNullException"></exception>
71.     public CollectionMemberSearchFilter(
72.         TQueryBuilder? query,
73.         NumberSearchFilter<int> count,
74.         bool reverse = false) : this(query, count, null, reverse)
75.     {
76.     }
78.     /// <summary>
79.     /// 初始化新的实例
80.     /// </summary>
81.     /// <param name="query">元素的查询</param>
82.     /// <param name="percent">比例搜索过滤器</param>
83.     /// <exception cref="ArgumentNullException"></exception>
84.     public CollectionMemberSearchFilter(
85.         TQueryBuilder query,
86.         NumberSearchFilter<double> percent,
87.         bool reverse = false) : this(query, null, percent, reverse)
88.     {
89.     }
91.     /// <summary>
92.     /// 初始化新的实例
93.     /// </summary>
94.     /// <param name="query">元素的查询</param>
95.     /// <param name="count">计数搜索过滤器</param>
96.     /// <param name="percent">比例搜索过滤器</param>
97.     /// <exception cref="ArgumentException"></exception>
98.     [JsonConstructor]
99.     public CollectionMemberSearchFilter(
100.         TQueryBuilder? query,
101.         NumberSearchFilter<int>? count = null,
102.         NumberSearchFilter<double>? percent = null,
103.         bool reverse = false)
104.     {
105.         if (count is null && percent is null || count is not null && percent is not null)
106.         {
107.             throw new ArgumentException($"{nameof(count)} 和 {nameof(percent)} 必须设置且只能设置其中一个。");
108.         }
110.         if (percent is not null && query is null)
111.         {
112.             throw new ArgumentException($"{nameof(percent)} 和 {nameof(query)} 必须同时设置。");
113.         }
115.         Query = query;
116.         Count = count;
117.         Percent = percent;
118.         Reverse = reverse;
119.     }
121.     /// <inheritdoc/>
122.     /// <exception cref="ArgumentException"></exception>
123.     /// <exception cref="InvalidDataException"></exception>
124.     public Expression<Func<TOwner, bool>>? GetWherePredicate<TOwner>(Expression<Func<TOwner, IEnumerable<T>>> memberAccessor)
125.     {
126.         ArgumentNullException.ThrowIfNull(memberAccessor);
128.         var asQueryable = _asQueryableOfT.MakeGenericMethod(typeof(T));
129.         Expression queryable = Expression.Call(null, asQueryable, [memberAccessor.Body]);
130.         Expression originalQueryable = queryable;
132.         var queryCount = _queryableCountOfT.MakeGenericMethod(typeof(T));
133.         Expression allCount = Expression.Call(null, queryCount, queryable);
134.         Expression? whereCount = null;
136.         var where = Query?.GetWherePredicate();
137.         if (where != null)
138.         {
139.             var queryableWhere = _queryableWhereOfT.MakeGenericMethod(typeof(T));
140.             queryable = Expression.Call(null, queryableWhere, [queryable, where]);
142.             whereCount = Expression.Call(null, queryCount, queryable);
143.         }
145.         Expression? resultBody = null;
146.         if (Count is not null)
147.         {
148.             var usedCount = whereCount ?? allCount;
150.             resultBody = Count.Operator switch
151.             {
152.                 ComparableNumberSearchOperator.Equal => TryUseAnyCall(Count.Operator, Count.Keys[0], queryable, out var anyCall)
153.                     ? anyCall
154.                     : Expression.Equal(usedCount, Expression.Constant(Count.Keys[0])),
155.                 ComparableNumberSearchOperator.In =>
156.                     Expression.Call(
157.                         null,
158.                         _enumerableContains,
159.                         [Expression.Constant(Count.Keys, typeof(IEnumerable<int>)), usedCount]
160.                     ),
161.                 ComparableNumberSearchOperator.LessThan => TryUseAnyCall(Count.Operator, Count.Keys[0], queryable, out var anyCall)
162.                     ? anyCall
163.                     : Expression.LessThan(usedCount, Expression.Constant(Count.Keys[0])),
164.                 ComparableNumberSearchOperator.LessThanOrEqual => TryUseAnyCall(Count.Operator, Count.Keys[0], queryable, out var anyCall)
165.                     ? anyCall
166.                     : Expression.LessThanOrEqual(usedCount, Expression.Constant(Count.Keys[0])),
167.                 ComparableNumberSearchOperator.GreaterThan => TryUseAnyCall(Count.Operator, Count.Keys[0], queryable, out var anyCall)
168.                     ? anyCall
169.                     : Expression.GreaterThan(usedCount, Expression.Constant(Count.Keys[0])),
170.                 ComparableNumberSearchOperator.GreaterThanOrEqual => TryUseAnyCall(Count.Operator, Count.Keys[0], queryable, out var anyCall)
171.                     ? anyCall
172.                     : Expression.GreaterThanOrEqual(usedCount, Expression.Constant(Count.Keys[0])),
173.                 ComparableNumberSearchOperator.BetweenOpen =>
174.                     Expression.AndAlso(
175.                         Expression.GreaterThan(usedCount, Expression.Constant(Count.Keys[0])),
176.                         Expression.LessThan(usedCount, Expression.Constant(Count.Keys[1]))
177.                     ),
178.                 ComparableNumberSearchOperator.BetweenLeftClosed =>
179.                     Expression.AndAlso(
180.                         Expression.GreaterThanOrEqual(usedCount, Expression.Constant(Count.Keys[0])),
181.                         Expression.LessThan(usedCount, Expression.Constant(Count.Keys[1]))
182.                     ),
183.                 ComparableNumberSearchOperator.BetweenRightClosed =>
184.                     Expression.AndAlso(
185.                         Expression.GreaterThan(usedCount, Expression.Constant(Count.Keys[0])),
186.                         Expression.LessThanOrEqual(usedCount, Expression.Constant(Count.Keys[1]))
187.                     ),
188.                 ComparableNumberSearchOperator.BetweenClosed =>
189.                     Expression.AndAlso(
190.                         Expression.GreaterThanOrEqual(usedCount, Expression.Constant(Count.Keys[0])),
191.                         Expression.LessThanOrEqual(usedCount, Expression.Constant(Count.Keys[1]))
192.                     ),
193.                 _ => throw new InvalidDataException(nameof(Count.Operator)),
194.             };
195.             if (Count.Reverse) resultBody = Expression.Not(resultBody);
196.         }
197.         else if (Percent is not null)
198.         {
199.             Debug.Assert(whereCount is not null);
201.             Expression doubleAllCount = Expression.Convert(allCount, typeof(double));
202.             whereCount = Expression.Convert(whereCount, typeof(double));
203.             Expression usedPercent = Expression.Divide(whereCount, doubleAllCount);
205.             var queryableAny = _queryableAnyOfT.MakeGenericMethod(typeof(T));
206.             usedPercent = Expression.Condition(Expression.Not(Expression.Call(null, queryableAny, originalQueryable)), Expression.Constant(0.0), usedPercent);
208.             resultBody = Percent.Operator switch
209.             {
210.                 ComparableNumberSearchOperator.Equal => Expression.Equal(usedPercent, Expression.Constant(Percent.Keys[0])),
211.                 ComparableNumberSearchOperator.In =>
212.                     Expression.Call(
213.                         null,
214.                         _enumerableContains,
215.                         [Expression.Constant(Percent.Keys, typeof(IEnumerable<double>)), usedPercent]
216.                     ),
217.                 ComparableNumberSearchOperator.LessThan => Expression.LessThan(usedPercent, Expression.Constant(Percent.Keys[0])),
218.                 ComparableNumberSearchOperator.LessThanOrEqual => Expression.LessThanOrEqual(usedPercent, Expression.Constant(Percent.Keys[0])),
219.                 ComparableNumberSearchOperator.GreaterThan => Expression.GreaterThan(usedPercent, Expression.Constant(Percent.Keys[0])),
220.                 ComparableNumberSearchOperator.GreaterThanOrEqual => Expression.GreaterThanOrEqual(usedPercent, Expression.Constant(Percent.Keys[0])),
221.                 ComparableNumberSearchOperator.BetweenOpen =>
222.                     Expression.AndAlso(
223.                         Expression.GreaterThan(usedPercent, Expression.Constant(Percent.Keys[0])),
224.                         Expression.LessThan(usedPercent, Expression.Constant(Percent.Keys[1]))
225.                     ),
226.                 ComparableNumberSearchOperator.BetweenLeftClosed =>
227.                     Expression.AndAlso(
228.                         Expression.GreaterThanOrEqual(usedPercent, Expression.Constant(Percent.Keys[0])),
229.                         Expression.LessThan(usedPercent, Expression.Constant(Percent.Keys[1]))
230.                     ),
231.                 ComparableNumberSearchOperator.BetweenRightClosed =>
232.                     Expression.AndAlso(
233.                         Expression.GreaterThan(usedPercent, Expression.Constant(Percent.Keys[0])),
234.                         Expression.LessThanOrEqual(usedPercent, Expression.Constant(Percent.Keys[1]))
235.                     ),
236.                 ComparableNumberSearchOperator.BetweenClosed =>
237.                     Expression.AndAlso(
238.                         Expression.GreaterThanOrEqual(usedPercent, Expression.Constant(Percent.Keys[0])),
239.                         Expression.LessThanOrEqual(usedPercent, Expression.Constant(Percent.Keys[1]))
240.                     ),
241.                 _ => throw new InvalidDataException(nameof(Percent.Operator)),
242.             };
243.             if (Percent.Reverse) resultBody = Expression.Not(resultBody);
244.         }
246.         Debug.Assert(resultBody is not null);
248.         var result = Expression.Lambda<Func<TOwner, bool>>(resultBody, memberAccessor.Parameters);
250.         return this.ApplyReversiblePredicate(result);
252.         static bool TryUseAnyCall(
253.             ComparableNumberSearchOperator @operator,
254.             int? key,
255.             Expression toCallAny,
256.             [NotNullWhen(true)] out Expression? result)
257.         {
258.             ArgumentNullException.ThrowIfNull(toCallAny);
260.             (bool shouldUseAny, bool shouldReverseAny) = (@operator, key) switch
261.             {
262.                 (ComparableNumberSearchOperator.Equal, 0) => (true, true),
263.                 (ComparableNumberSearchOperator.LessThan, 1) => (true, true),
264.                 (ComparableNumberSearchOperator.LessThanOrEqual, 0) => (true, true),
265.                 (ComparableNumberSearchOperator.GreaterThan, 0) => (true, false),
266.                 (ComparableNumberSearchOperator.GreaterThanOrEqual, 1) => (true, false),
267.                 _ => (false, false),
268.             };
270.             result = null;
271.             if (shouldUseAny)
272.             {
273.                 result = Expression.Call(
274.                     null,
275.                     _queryableAnyOfT.MakeGenericMethod(typeof(T)),
276.                     [toCallAny]
277.                 );
279.                 if (shouldReverseAny)
280.                 {
281.                     result = Expression.Not(result);
282.                 }
284.                 return true;
285.             }
287.             return false;
288.         }
289.     }
290. }

复制代码

辅助类型用于统一定义表达式的拼接方式等，因为这些拼接对于大多数基础数据类型来说都是通用的。

1. internal static class ScalarSearchFilterExtensions
2. {
3.     private static readonly MethodInfo _enumerableContainsOfT = typeof(Enumerable)
4.         .GetMethods()
5.         .Where(static m => m.Name is nameof(Enumerable.Contains))
6.         .Single(static m => m.GetParameters().Length is 2);
8.     internal static string? GetKeysCheckMessage<T>(ICollection<T> keys, ComparableNumberSearchOperator @operator)
9.     {
10.         string? exceptionHint = null;
11.         switch (@operator)
12.         {
13.             case ComparableNumberSearchOperator.Equal:
14.                 if (keys is { Count: > 1 })
15.                 {
16.                     exceptionHint = $"必须设置一个元素。";
17.                 }
18.                 break;
19.             case ComparableNumberSearchOperator.In:
20.                 if (keys is { Count: < 2 })
21.                 {
22.                     exceptionHint = $"必须设置多个元素。";
23.                 }
24.                 break;
25.             case ComparableNumberSearchOperator.LessThan:
26.                 goto case ComparableNumberSearchOperator.Equal;
27.             case ComparableNumberSearchOperator.LessThanOrEqual:
28.                 goto case ComparableNumberSearchOperator.Equal;
29.             case ComparableNumberSearchOperator.GreaterThan:
30.                 goto case ComparableNumberSearchOperator.Equal;
31.             case ComparableNumberSearchOperator.GreaterThanOrEqual:
32.                 goto case ComparableNumberSearchOperator.Equal;
33.             case ComparableNumberSearchOperator.BetweenOpen:
34.                 goto case ComparableNumberSearchOperator.BetweenClosed;
35.             case ComparableNumberSearchOperator.BetweenLeftClosed:
36.                 goto case ComparableNumberSearchOperator.BetweenClosed;
37.             case ComparableNumberSearchOperator.BetweenRightClosed:
38.                 goto case ComparableNumberSearchOperator.BetweenClosed;
39.             case ComparableNumberSearchOperator.BetweenClosed:
40.                 if (keys is { Count: not 2 })
41.                 {
42.                     exceptionHint = $"必须设置两个元素。";
43.                 }
44.                 break;
45.             case ComparableNumberSearchOperator.InBetweenOpen:
46.                 if (keys is { Count: < 4 } || keys.Count % 2 != 0)
47.                 {
48.                     exceptionHint = $"必须设置不少于四个的偶数个元素。";
49.                 }
50.                 break;
51.             case ComparableNumberSearchOperator.InBetweenLeftClosed:
52.                 goto case ComparableNumberSearchOperator.InBetweenOpen;
53.             case ComparableNumberSearchOperator.InBetweenRightClosed:
54.                 goto case ComparableNumberSearchOperator.InBetweenOpen;
55.             case ComparableNumberSearchOperator.InBetweenClosed:
56.                 goto case ComparableNumberSearchOperator.InBetweenOpen;
57.             default:
58.                 exceptionHint = "的元素数量错误。";
59.                 break;
60.         };
62.         if (exceptionHint is not null) return $"当 {nameof(@operator)} 的值为 {@operator} 时{exceptionHint}";
63.         else return null;
64.     }
66.     internal static void NullKeyCheck<T>(IReadOnlyList<T?> keys)
67.         where T : struct
68.     {
69.         if (keys.Any(static n => n is null)) throw new InvalidOperationException("不能使用值为空的元素搜索值不能为空的成员。");
70.     }
72.     internal static Expression<Func<TOwner, bool>> GetWherePredicateExtension<TOwner, TNumber>(
73.         IReadOnlyList<TNumber?> keys,
74.         ComparableNumberSearchOperator @operator,
75.         Expression<Func<TOwner, TNumber>> memberAccessor)
76.         where TNumber : struct
77.     {
78.         var typeOfNumber = typeof(TNumber);
79.         var _enumerableContains = @operator is ComparableNumberSearchOperator.In ? _enumerableContainsOfT.MakeGenericMethod([typeOfNumber]) : null;
81.         Expression newBody = @operator switch
82.         {
83.             ComparableNumberSearchOperator.Equal => Expression.Equal(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)),
84.             ComparableNumberSearchOperator.In => Expression.Call(null, _enumerableContains!, [Expression.Constant(keys.Cast<TNumber>().ToList(), typeof(IEnumerable<TNumber>)), memberAccessor.Body]),
85.             ComparableNumberSearchOperator.LessThan => Expression.LessThan(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)),
86.             ComparableNumberSearchOperator.LessThanOrEqual => Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)),
87.             ComparableNumberSearchOperator.GreaterThan => Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)),
88.             ComparableNumberSearchOperator.GreaterThanOrEqual => Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)),
89.             ComparableNumberSearchOperator.BetweenOpen => Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(keys[1], typeOfNumber))),
90.             ComparableNumberSearchOperator.BetweenLeftClosed => Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(keys[1], typeOfNumber))),
91.             ComparableNumberSearchOperator.BetweenRightClosed => Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keys[1], typeOfNumber))),
92.             ComparableNumberSearchOperator.BetweenClosed => Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keys[0], typeOfNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keys[1], typeOfNumber))),
93.             ComparableNumberSearchOperator.InBetweenOpen => CombineInBetweenBody(keys, @operator, memberAccessor),
94.             ComparableNumberSearchOperator.InBetweenLeftClosed => CombineInBetweenBody(keys, @operator, memberAccessor),
95.             ComparableNumberSearchOperator.InBetweenRightClosed => CombineInBetweenBody(keys, @operator, memberAccessor),
96.             ComparableNumberSearchOperator.InBetweenClosed => CombineInBetweenBody(keys, @operator, memberAccessor),
97.             _ => throw new InvalidDataException(nameof(ComparableNumberSearchOperator))
98.         };
100.         return Expression.Lambda<Func<TOwner, bool>>(newBody, memberAccessor.Parameters);
101.     }
103.     internal static Expression<Func<TOwner, bool>> GetWherePredicateExtension<TOwner, TNumber>(
104.         IReadOnlyList<TNumber?> keys,
105.         ComparableNumberSearchOperator @operator,
106.         Expression<Func<TOwner, TNumber?>> memberAccessor)
107.         where TNumber : struct
108.     {
109.         var typeOfNullableNumber = typeof(TNumber?);
110.         var enumerableContains = @operator is ComparableNumberSearchOperator.In ? _enumerableContainsOfT.MakeGenericMethod([typeOfNullableNumber]) : null;
112.         Expression newBody = @operator switch
113.         {
114.             ComparableNumberSearchOperator.Equal => Expression.Equal(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)),
115.             ComparableNumberSearchOperator.In => Expression.Call(null, enumerableContains!, [Expression.Constant(keys, typeof(IEnumerable<TNumber?>)), memberAccessor.Body]),
116.             ComparableNumberSearchOperator.LessThan => Expression.LessThan(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)),
117.             ComparableNumberSearchOperator.LessThanOrEqual => Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)),
118.             ComparableNumberSearchOperator.GreaterThan => Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)),
119.             ComparableNumberSearchOperator.GreaterThanOrEqual => Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)),
120.             ComparableNumberSearchOperator.BetweenOpen => Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(keys[1], typeOfNullableNumber))),
121.             ComparableNumberSearchOperator.BetweenLeftClosed => Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(keys[1], typeOfNullableNumber))),
122.             ComparableNumberSearchOperator.BetweenRightClosed => Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keys[1], typeOfNullableNumber))),
123.             ComparableNumberSearchOperator.BetweenClosed => Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keys[0], typeOfNullableNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keys[1], typeOfNullableNumber))),
124.             ComparableNumberSearchOperator.InBetweenOpen => CombineInBetweenBody(keys, @operator, memberAccessor),
125.             ComparableNumberSearchOperator.InBetweenLeftClosed => CombineInBetweenBody(keys, @operator, memberAccessor),
126.             ComparableNumberSearchOperator.InBetweenRightClosed => CombineInBetweenBody(keys, @operator, memberAccessor),
127.             ComparableNumberSearchOperator.InBetweenClosed => CombineInBetweenBody(keys, @operator, memberAccessor),
128.             _ => throw new InvalidDataException(nameof(ComparableNumberSearchOperator))
129.         };
131.         return Expression.Lambda<Func<TOwner, bool>>(newBody, memberAccessor.Parameters);
132.     }
134.     private static Expression CombineInBetweenBody<TOwner, TNumber>(
135.         IReadOnlyList<TNumber?> keys,
136.         ComparableNumberSearchOperator @operator,
137.         Expression<Func<TOwner, TNumber>> memberAccessor)
138.         where TNumber : struct
139.     {
140.         var typeOfNumber = typeof(TNumber);
141.         var keysGroups = keys.Chunk(2);
143.         Expression newBody = @operator switch
144.         {
145.             ComparableNumberSearchOperator.InBetweenOpen => Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keysGroups.First()[0], typeOfNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(keysGroups.First()[1], typeOfNumber))),
146.             ComparableNumberSearchOperator.InBetweenLeftClosed => Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keysGroups.First()[0], typeOfNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(keysGroups.First()[1], typeOfNumber))),
147.             ComparableNumberSearchOperator.InBetweenRightClosed => Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keysGroups.First()[0], typeOfNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keysGroups.First()[1], typeOfNumber))),
148.             ComparableNumberSearchOperator.InBetweenClosed => Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keysGroups.First()[0], typeOfNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keysGroups.First()[1], typeOfNumber))),
149.             _ => throw new InvalidDataException(nameof(ComparableNumberSearchOperator))
150.         };
152.         foreach (var inKeys in keysGroups.Skip(1))
153.         {
154.             newBody = @operator switch
155.             {
156.                 ComparableNumberSearchOperator.InBetweenOpen => Expression.OrElse(newBody, Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(inKeys[0], typeOfNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(inKeys[1], typeOfNumber)))),
157.                 ComparableNumberSearchOperator.InBetweenLeftClosed => Expression.OrElse(newBody, Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(inKeys[0], typeOfNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(inKeys[1], typeOfNumber)))),
158.                 ComparableNumberSearchOperator.InBetweenRightClosed => Expression.OrElse(newBody, Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(inKeys[0], typeOfNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(inKeys[1], typeOfNumber)))),
159.                 ComparableNumberSearchOperator.InBetweenClosed => Expression.OrElse(newBody, Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(inKeys[0], typeOfNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(inKeys[1], typeOfNumber)))),
160.                 _ => throw new InvalidDataException(nameof(ComparableNumberSearchOperator))
161.             };
162.         }
164.         return newBody;
165.     }
167.     private static Expression CombineInBetweenBody<TOwner, TNumber>(
168.         IReadOnlyList<TNumber?> keys,
169.         ComparableNumberSearchOperator @operator,
170.         Expression<Func<TOwner, TNumber?>> memberAccessor)
171.         where TNumber : struct
172.     {
173.         var typeOfNullableNumber = typeof(TNumber?);
175.         var keysGroups = keys.Chunk(2);
177.         Expression newBody = @operator switch
178.         {
179.             ComparableNumberSearchOperator.InBetweenOpen => Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keysGroups.First()[0], typeOfNullableNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(keysGroups.First()[1], typeOfNullableNumber))),
180.             ComparableNumberSearchOperator.InBetweenLeftClosed => Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keysGroups.First()[0], typeOfNullableNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(keysGroups.First()[1], typeOfNullableNumber))),
181.             ComparableNumberSearchOperator.InBetweenRightClosed => Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(keysGroups.First()[0], typeOfNullableNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keysGroups.First()[1], typeOfNullableNumber))),
182.             ComparableNumberSearchOperator.InBetweenClosed => Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(keysGroups.First()[0], typeOfNullableNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(keysGroups.First()[1], typeOfNullableNumber))),
183.             _ => throw new InvalidDataException(nameof(ComparableNumberSearchOperator))
184.         };
186.         foreach (var inKeys in keysGroups.Skip(1))
187.         {
188.             newBody = @operator switch
189.             {
190.                 ComparableNumberSearchOperator.InBetweenOpen => Expression.OrElse(newBody, Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(inKeys[0], typeOfNullableNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(inKeys[1], typeOfNullableNumber)))),
191.                 ComparableNumberSearchOperator.InBetweenLeftClosed => Expression.OrElse(newBody, Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(inKeys[0], typeOfNullableNumber)), Expression.LessThan(memberAccessor.Body, Expression.Constant(inKeys[1], typeOfNullableNumber)))),
192.                 ComparableNumberSearchOperator.InBetweenRightClosed => Expression.OrElse(newBody, Expression.AndAlso(Expression.GreaterThan(memberAccessor.Body, Expression.Constant(inKeys[0], typeOfNullableNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(inKeys[1], typeOfNullableNumber)))),
193.                 ComparableNumberSearchOperator.InBetweenClosed => Expression.OrElse(newBody, Expression.AndAlso(Expression.GreaterThanOrEqual(memberAccessor.Body, Expression.Constant(inKeys[0], typeOfNullableNumber)), Expression.LessThanOrEqual(memberAccessor.Body, Expression.Constant(inKeys[1], typeOfNullableNumber)))),
194.                 _ => throw new InvalidDataException(nameof(ComparableNumberSearchOperator))
195.             };
196.         }
198.         return newBody;
199.     }
200. }

复制代码

专用于返回bool类型的表达式的合并扩展。
扩展复杂筛选支持

偶然查询条件可能比较复杂，单个天生器无法表达。因此必要一个用于形貌更复杂的条件的天生器，单个天生器无法形貌的环境利用多个天生器组合来实现。既然复杂条件是由单个条件组合而来，最好能复用已经定义好的单个筛选器。

1. /// <summary>
2. /// 合并表达式 And Or Not扩展方法
3. /// </summary>
4. public static class ExpressionExtensions
5. {
6.     /// <summary>
7.     /// 合并表达式 expr1 AND expr2
8.     /// </summary>
9.     /// <typeparam name="T">表达式参数类型</typeparam>
10.     /// <param name="expr1">待合并的表达式1</param>
11.     /// <param name="expr2">待合并的表达式2</param>
12.     /// <returns>合并的表达式</returns>
13.     public static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
14.     {
15.         ArgumentNullException.ThrowIfNull(nameof(expr1));
16.         ArgumentNullException.ThrowIfNull(nameof(expr2));
18.         ParameterReplaceExpressionVisitor visitor = new();
19.         Dictionary<ParameterExpression, ParameterExpression> replaceMapping = [];
21.         ParameterExpression newParameter = Expression.Parameter(typeof(T), expr1.Parameters[0].Name);
22.         replaceMapping[expr1.Parameters[0]] = newParameter;
24.         var left = visitor.ReplaceParameter(expr1, replaceMapping);
26.         replaceMapping.Clear();
27.         replaceMapping[expr2.Parameters[0]] = newParameter;
28.         var right = visitor.ReplaceParameter(expr2, replaceMapping);
30.         BinaryExpression body = Expression.AndAlso(left!.Body, right!.Body);
31.         return Expression.Lambda<Func<T, bool>>(body, newParameter);
32.     }
34.     /// <summary>
35.     /// 合并多个表达式 expr1 AND expr2 AND ...
36.     /// </summary>
37.     /// <typeparam name="T">表达式参数类型</typeparam>
38.     /// <param name="source">待合并的表达式集合</param>
39.     /// <returns>合并的表达式</returns>
40.     public static Expression<Func<T, bool>>? AndAlsoAll<T>(this IEnumerable<Expression<Func<T, bool>>> source)
41.     {
42.         ArgumentNullException.ThrowIfNull(nameof(source));
44.         if (!source.Any() || !source.Skip(1).Any()) return source.FirstOrDefault();
46.         ParameterReplaceExpressionVisitor visitor = new();
47.         Dictionary<ParameterExpression, ParameterExpression> replaceMapping = [];
49.         var first = source.First();
50.         ParameterExpression newParameter = Expression.Parameter(typeof(T), first.Parameters[0].Name);
51.         replaceMapping[first.Parameters[0]] = newParameter;
53.         var left = visitor.ReplaceParameter(first, replaceMapping);
55.         List<LambdaExpression> rights = [];
56.         foreach (var right in source.Skip(1))
57.         {
58.             replaceMapping.Clear();
59.             replaceMapping[right.Parameters[0]] = newParameter;
61.             rights.Add(visitor.ReplaceParameter(right, replaceMapping)!);
62.         }
64.         BinaryExpression body = Expression.AndAlso(left!.Body, rights[0].Body);
65.         foreach (var right in rights.Skip(1))
66.         {
67.             body = Expression.AndAlso(body, right.Body);
68.         }
69.         return Expression.Lambda<Func<T, bool>>(body, newParameter);
70.     }
72.     /// <summary>
73.     /// 合并表达式 expr1 OR expr2
74.     /// </summary>
75.     /// <typeparam name="T">表达式参数类型</typeparam>
76.     /// <param name="expr1">待合并的表达式1</param>
77.     /// <param name="expr2">待合并的表达式2</param>
78.     /// <returns>合并的表达式</returns>
79.     public static Expression<Func<T, bool>> OrElse<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
80.     {
81.         ArgumentNullException.ThrowIfNull(nameof(expr1));
82.         ArgumentNullException.ThrowIfNull(nameof(expr2));
84.         ParameterReplaceExpressionVisitor visitor = new();
85.         Dictionary<ParameterExpression, ParameterExpression> replaceMapping = [];
87.         ParameterExpression newParameter = Expression.Parameter(typeof(T), expr1.Parameters[0].Name);
88.         replaceMapping[expr1.Parameters[0]] = newParameter;
90.         var left = visitor.ReplaceParameter(expr1, replaceMapping);
92.         replaceMapping.Clear();
93.         replaceMapping[expr2.Parameters[0]] = newParameter;
94.         var right = visitor.ReplaceParameter(expr2, replaceMapping);
96.         BinaryExpression body = Expression.OrElse(left!.Body, right!.Body);
97.         return Expression.Lambda<Func<T, bool>>(body, newParameter);
98.     }
100.     /// <summary>
101.     /// 合并多个表达式 expr1 OR expr2 OR ...
102.     /// </summary>
103.     /// <typeparam name="T">表达式参数类型</typeparam>
104.     /// <returns>合并的表达式</returns>
105.     public static Expression<Func<T, bool>>? OrElseAll<T>(this IEnumerable<Expression<Func<T, bool>>> source)
106.     {
107.         ArgumentNullException.ThrowIfNull(nameof(source));
109.         if (!source.Any() || !source.Skip(1).Any()) return source.FirstOrDefault();
111.         ParameterReplaceExpressionVisitor visitor = new();
112.         Dictionary<ParameterExpression, ParameterExpression> replaceMapping = [];
114.         var first = source.First();
115.         ParameterExpression newParameter = Expression.Parameter(typeof(T), first.Parameters[0].Name);
116.         replaceMapping[first.Parameters[0]] = newParameter;
118.         var left = visitor.ReplaceParameter(first, replaceMapping);
120.         List<LambdaExpression> rights = [];
121.         foreach (var right in source.Skip(1))
122.         {
123.             replaceMapping.Clear();
124.             replaceMapping[right.Parameters[0]] = newParameter;
126.             rights.Add(visitor.ReplaceParameter(right, replaceMapping)!);
127.         }
129.         BinaryExpression body = Expression.OrElse(left!.Body, rights[0].Body);
130.         foreach (var right in rights.Skip(1))
131.         {
132.             body = Expression.OrElse(body, right.Body);
133.         }
134.         return Expression.Lambda<Func<T, bool>>(body, newParameter);
135.     }
137.     /// <summary>
138.     /// 表达式取非 NOT
139.     /// </summary>
140.     /// <typeparam name="T">表达式参数类型</typeparam>
141.     /// <param name="expr">原表达式</param>
142.     /// <returns>已经取非的表达式</returns>
143.     public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expr)
144.     {
145.         ArgumentNullException.ThrowIfNull(nameof(expr));
147.         UnaryExpression body = Expression.Not(expr.Body);
148.         return Expression.Lambda<Func<T, bool>>(body, expr.Parameters[0]);
149.     }
150. }
152. /// <summary>
153. /// 替换表达式参数的访问器
154. /// </summary>
155. public sealed class ParameterReplaceExpressionVisitor : ExpressionVisitor
156. {
157.     private readonly Lock _lock = new();
159.     private volatile bool _calledFromReplaceParameter = false;
160.     private IReadOnlyDictionary<ParameterExpression, ParameterExpression>? _parameterReplaceMapping;
162.     /// <summary>
163.     /// 把指定表达式的参数替换为新的参数。
164.     /// </summary>
165.     /// <param name="expr">要替换参数的表达式。</param>
166.     /// <param name="parameterReplaceMapping">替换用的新参数表达式映射。Key是表达式中的现有参数，Value是新参数。</param>
167.     /// <returns>已替换参数的表达式。</returns>
168.     /// <exception cref="ArgumentException"></exception>
169.     /// <exception cref="ArgumentNullException"></exception>
170.     public LambdaExpression? ReplaceParameter(LambdaExpression expr, IReadOnlyDictionary<ParameterExpression, ParameterExpression> parameterReplaceMapping)
171.     {
172.         ArgumentNullException.ThrowIfNull(expr);
173.         ArgumentNullException.ThrowIfNull(parameterReplaceMapping);
175.         if (expr.Parameters.Count == 0) throw new ArgumentException($"{nameof(expr)}不能是无参数表达式。", nameof(expr));
177.         lock (_lock)
178.         {
179.             try
180.             {
181.                 // 复制参数避免多线程修改损坏参数
182.                 var replaceCopy = parameterReplaceMapping.AsEnumerable().ToDictionary();
184.                 if (replaceCopy.Count == 0) throw new ArgumentException($"{nameof(parameterReplaceMapping)}不能没有元素。", nameof(parameterReplaceMapping));
186.                 if (expr.Parameters.Count < replaceCopy.Count) throw new ArgumentException($"{nameof(parameterReplaceMapping)}的元素数量不能大于表达式的参数数量。", nameof(parameterReplaceMapping));
188.                 foreach (var mapping in replaceCopy)
189.                 {
190.                     if (!expr.Parameters.Contains(mapping.Key))
191.                         throw new ArgumentException("被替换的参数必须是表达式使用的参数。", nameof(parameterReplaceMapping));
192.                 }
194.                 _parameterReplaceMapping = replaceCopy;
195.                 _calledFromReplaceParameter = true;
197.                 var result = Visit(expr);
199.                 return result as LambdaExpression;
200.             }
201.             catch
202.             {
203.                 throw;
204.             }
205.             finally
206.             {
207.                 _calledFromReplaceParameter = false;
208.                 _parameterReplaceMapping = null;
209.             }
210.         }
211.     }
213.     [return: NotNullIfNotNull(nameof(node))]
214.     public override Expression? Visit(Expression? node)
215.     {
216.         if (!_calledFromReplaceParameter) throw new InvalidOperationException($"Don't call directly, call {nameof(ReplaceParameter)} instead.");
218.         return base.Visit(node);
219.     }
221.     protected override Expression VisitParameter(ParameterExpression node)
222.     {
223.         if (_parameterReplaceMapping!.TryGetValue(node, out var newParameter)) return newParameter;
225.         return base.VisitParameter(node);
226.     }
227. }

复制代码

高级查询接口允许组合和嵌套任意多个筛选器以实现更复杂的条件。

1. /// <summary>
2. /// 支持复杂条件嵌套的高级查询条件构造器接口
3. /// </summary>
4. /// <typeparam name="TFilterPredicateBuilder">基础查询条件构造器</typeparam>
5. /// <typeparam name="T">要查询的数据类型</typeparam>
6. public interface IAdvancedFilterPredicateBuilder<out TFilterPredicateBuilder, T> : IFilterPredicateBuilder<T>
7.     where TFilterPredicateBuilder : IFilterPredicateBuilder<T>
8. {
9.     /// <summary>
10.     /// 基础查询条件集合
11.     /// </summary>
12.     IReadOnlyList<TFilterPredicateBuilder>? Filters { get; }
14.     /// <summary>
15.     /// 高级查询条件组集合
16.     /// </summary>
17.     IReadOnlyList<IAdvancedFilterPredicateBuilder<TFilterPredicateBuilder, T>>? FilterGroups { get; }
18. }

复制代码

单个条件可以获取对应的筛选表达式，那么这些条件的组合也就是对这些表达式进行组合。
添加排序和分页支持

分页的前提是排序，否则分页的效果不稳定。对于分页，通常还想获得符合条件的数据总量用于计算页数，但是排序并不影响总数计算。如果能在计算总数时忽略排序，仅在获取某一页数据时利用排序最好。这就要求我们分别存储和处理筛选条件和排序条件。筛选条件的问题已经在前面解决了，这里只必要关注排序条件的问题。
排序的概念接口

1. /// <summary>
2. /// 支持复杂条件嵌套的高级查询构造器
3. /// </summary>
4. /// <typeparam name="TQueryBuilder">基础查询构造器</typeparam>
5. /// <typeparam name="T">要查询的数据类型</typeparam>
6. /// <param name="Queries">基础查询条件集合</param>
7. /// <param name="QueryGroups">高级查询条件组集合</param>
8. /// <param name="CombineType">条件组合方式</param>
9. /// <param name="Reverse">是否反转条件</param>
10. public record AdvancedQueryBuilder<TQueryBuilder, T>(
11.     ImmutableList<TQueryBuilder>? Queries = null,
12.     ImmutableList<AdvancedQueryBuilder<TQueryBuilder, T>>? QueryGroups = null,
13.     [EnumDataType(typeof(PredicateCombineKind))]
14.     PredicateCombineKind? CombineType = PredicateCombineKind.And,
15.     bool Reverse = false)
16.     : IAdvancedFilterPredicateBuilder<TQueryBuilder, T>
17.     , IPredicateReversible
18.     where TQueryBuilder : IFilterPredicateBuilder<T>
19. {
20.     /// <inheritdoc/>
21.     public IReadOnlyList<TQueryBuilder>? Filters => Queries;
23.     /// <inheritdoc/>
24.     public IReadOnlyList<IAdvancedFilterPredicateBuilder<TQueryBuilder, T>>? FilterGroups => QueryGroups;
26.     /// <summary>
27.     /// 获取查询条件
28.     /// </summary>
29.     /// <returns>组合完成的查询条件</returns>
30.     public Expression<Func<T, bool>>? GetWherePredicate()
31.     {
32.         var where = CombinePredicates(Queries?.Select(static q => q.GetWherePredicate())
33.             .Concat(QueryGroups?.Select(static qg => qg.GetWherePredicate()) ?? [])
34.             .Where(static p => p is not null)!);
36.         return this.ApplyReversiblePredicate(where);
37.     }
39.     /// <summary>
40.     /// 组合查询条件
41.     /// </summary>
42.     /// <param name="predicates">待组合的子条件</param>
43.     /// <returns></returns>
44.     /// <exception cref="NotSupportedException"></exception>
45.     protected Expression<Func<T, bool>>? CombinePredicates(IEnumerable<Expression<Func<T, bool>>>? predicates)
46.     {
47.         var predicate = predicates?.FirstOrDefault();
48.         if (predicates?.Any() is true)
49.         {
50.             predicate = CombineType switch
51.             {
52.                 PredicateCombineKind.And => predicates?.AndAlsoAll(),
53.                 PredicateCombineKind.Or => predicates?.OrElseAll(),
54.                 _ => throw new NotSupportedException(CombineType.ToString()),
55.             };
56.         }
58.         return predicate;
59.     }
60. }

复制代码

同样的，第一个接口只形貌如作甚查询附加排序，第二个接口形貌序列化传输的方式。LINQ中的排序方法参数是一个排序关键字属性访问表达式，属性的类型就是表达式的返回值类型，属性类型千变万化，因此只能利用返回object的表达式来存储。表达式关键字自己无法序列化传输，因此笔者选择利用枚举来指代表达式，这也同时限定了可用于排序的属性，有利于安全。
分页的概念接口

现在有两种流行的分页方式，偏移量分页和游标分页。偏移量分页支持随机页码跳转，也必要提前计算数据总数，数据量大或访问尾部页码时性能会下降。游标分页则是根据唯一键游标排序来进行，可以是两个游标之间的数据或单个游标和获取数据量的组合。在返回的效果中必要附带相邻页面的起始游标，因此实际查询数据时必要多查一条数据，多查的这一条数据只必要游标值，不必要数据自己。本文以偏移量分页为例。

1. /// <summary>
2. /// 排序查询构造器接口
3. /// </summary>
4. /// <typeparam name="T">查询的元素类型</typeparam>
5. public interface IOrderedQueryBuilder<T>
6. {
7.     /// <summary>
8.     /// 对查询应用排序
9.     /// </summary>
10.     /// <param name="query">原始查询</param>
11.     /// <returns>已排序的查询</returns>
12.     IOrderedQueryable<T> ApplyOrder(IQueryable<T> query);
13. }
15. /// <summary>
16. /// 可排序查询接口
17. /// </summary>
18. /// <typeparam name="T">查询的元素类型</typeparam>
19. /// <typeparam name="TOrderKey">可用的排序关键字枚举类型</typeparam>
21. public interface IKeySelectorOrderedQueryBuilder<T, TOrderKey> : IOrderedQueryBuilder<T>
22.     where TOrderKey : struct, Enum
23. {
24.     /// <summary>
25.     /// 获取支持的排序关键字选择器
26.     /// </summary>
27.     IReadOnlyDictionary<TOrderKey, Expression<Func<T, object?>>> GetSupportedOrderKeySelectors();
29.     /// <summary>
30.     /// 排序关键字信息
31.     /// </summary>
32.     ImmutableList<OrderInfo<TOrderKey>>? OrderKeys { get; }
33. }
35. /// <summary>
36. /// 排序信息
37. /// </summary>
38. /// <typeparam name="T">排序对象的类型</typeparam>
39. /// <param name="Key">排序关键字</param>
40. /// <param name="OrderKind">排序方式</param>
41. public record OrderInfo<T>(
42.     T Key,
43.     [EnumDataType(typeof(OrderKind))]
44.     OrderKind OrderKind = OrderKind.Asc)
45.     where T : struct, Enum
46. {
47.     /// <summary>
48.     /// 排序关键字
49.     /// </summary>
50.     public T Key { get; } = CheckOrderKey(Key);
52.     private static T CheckOrderKey(T value)
53.     {
54.         if (!Enum.IsDefined(value)) throw new InvalidEnumArgumentException(nameof(Key), int.Parse(value.ToString()), typeof(T));
55.         return value;
56.     }
57. }
59. /// <summary>
60. /// 排序方式
61. /// </summary>
62. public enum OrderKind
63. {
64.     /// <summary>
65.     /// 升序
66.     /// </summary>
67.     Asc = 1,
69.     /// <summary>
70.     /// 降序
71.     /// </summary>
72.     Desc = 2,
73. }

复制代码

完整的分页查询天生器

1. /// <summary>
2. /// 可页码分页查询接口
3. /// </summary>
4. public interface IOffsetPagingSupport
5. {
6.     /// <summary>
7.     /// 分页信息
8.     /// </summary>
9.     OffsetPageInfo OffsetPage { get; }
10. }
12. /// <summary>
13. /// 页码分页信息
14. /// </summary>
15. /// <param name="PageIndex">页码</param>
16. /// <param name="PageSize">页面大小</param>
17. public record OffsetPageInfo(
18.     [Range(1, int.MaxValue, ErrorMessage = DataAnnotationErrorMessageDefaults.Range)] int PageIndex = 1,
19.     [Range(1, int.MaxValue, ErrorMessage = DataAnnotationErrorMessageDefaults.Range)] int PageSize = 10
20. )
21. {
22.     /// <summary>
23.     /// 跳过的页数
24.     /// </summary>
25.     public int SkipedPageCount => PageIndex - 1;
27.     /// <summary>
28.     /// 跳过的元素数量
29.     /// </summary>
30.     public int SkipedElementCount => SkipedPageCount * PageSize;
31. }
33. /// <summary>
34. /// 页码分页查询构造扩展
35. /// </summary>
36. public static class OffsetPageQueryBuilderExtensions
37. {
38.     /// <summary>
39.     /// 页码分页
40.     /// </summary>
41.     /// <typeparam name="T">查询的元素类型</typeparam>
42.     /// <param name="offsetPaging">分页信息</param>
43.     /// <param name="query">要应用分页的查询</param>
44.     /// <returns>已页码分页的查询</returns>
45.     public static IQueryable<T> OffsetPage<T>(this IOffsetPagingSupport offsetPaging, IQueryable<T> query)
46.     {
47.         ArgumentNullException.ThrowIfNull(offsetPaging);
48.         ArgumentNullException.ThrowIfNull(query);
49.         var paging = offsetPaging.OffsetPage;
51.         return query.Skip(paging.SkipedElementCount).Take(paging.PageSize);
52.     }
53. }

复制代码

此处的抽象基类不实现关键字排序是因为无法确定最终查询是否支持关键字排序，有可能是在代码中定义的静态排序规则。如果确实支持关键字排序，在最终类型上实现关键字排序接口即可。扩展类型则用于快速实现关键字排序表达式天生。
利用示例

演示用数据类型

1. /// <summary>
2. /// 分页查询构造器
3. /// </summary>
4. /// <typeparam name="TQueryBuilder">查询构造器类型</typeparam>
5. /// <typeparam name="T">查询的数据类型</typeparam>
6. /// <param name="Query">基础查询</param>
7. /// <param name="OffsetPage">分页信息</param>
8. public abstract record OffsetPagedQueryBuilder<TQueryBuilder, T>(
9.     TQueryBuilder Query,
10.     OffsetPageInfo? OffsetPage = null)
11.     : IFilterPredicateBuilder<T>
12.     , IOrderedQueryBuilder<T>
13.     , IOffsetPagingSupport
14.     where TQueryBuilder : IFilterPredicateBuilder<T>
15. {
16.     /// <inheritdoc/>
17.     public Expression<Func<T, bool>>? GetWherePredicate() => Query.GetWherePredicate();
19.     /// <inheritdoc/>
20.     public virtual OffsetPageInfo OffsetPage { get; } = OffsetPage ?? new();
22.     /// <inheritdoc/>
23.     public abstract IOrderedQueryable<T> ApplyOrder(IQueryable<T> query);
24. }
26. /// <summary>
27. /// 查询的排序方法
28. /// </summary>
29. public enum QueryableOrderMethod
30. {
31.     /// <summary>
32.     /// 优先升序
33.     /// </summary>
34.     OrderBy = 1,
36.     /// <summary>
37.     /// 优先降序
38.     /// </summary>
39.     OrderByDescending,
41.     /// <summary>
42.     /// 次一级升序
43.     /// </summary>
44.     ThenBy,
46.     /// <summary>
47.     /// 次一级降序
48.     /// </summary>
49.     ThenByDescending
50. }
52. /// <summary>
53. /// 关键字排序查询构造器扩展
54. /// </summary>
55. public static class KeySelectorOrderQueryBuilderExtensions
56. {
57.     private static readonly MethodInfo _queryableOederByOfT = typeof(Queryable).GetMethods()
58.         .Single(static m => m.Name is nameof(Queryable.OrderBy) && m.GetParameters().Length is 2);
60.     private static readonly MethodInfo _queryableThenByOfT = typeof(Queryable).GetMethods()
61.         .Single(static m => m.Name is nameof(Queryable.ThenBy) && m.GetParameters().Length is 2);
63.     private static readonly MethodInfo _queryableOrderByDescendingOfT = typeof(Queryable).GetMethods()
64.         .Single(static m => m.Name is nameof(Queryable.OrderByDescending) && m.GetParameters().Length is 2);
66.     private static readonly MethodInfo _queryableThenByDescendingOfT = typeof(Queryable).GetMethods()
67.         .Single(static m => m.Name is nameof(Queryable.ThenByDescending) && m.GetParameters().Length is 2);
69.     /// <summary>
70.     /// 对查询应用关键字排序
71.     /// </summary>
72.     /// <typeparam name="T">查询的元素类型</typeparam>
73.     /// <typeparam name="TOrderKey">可用的排序关键字类型</typeparam>
74.     /// <param name="OrderInfos">排序信息</param>
75.     /// <param name="query">原始查询</param>
76.     /// <returns>已排序的查询</returns>
77.     /// <exception cref="InvalidDataException"></exception>
78.     public static IOrderedQueryable<T> ApplyKeyedOrder<T, TOrderKey>(this IKeySelectorOrderedQueryBuilder<T, TOrderKey> OrderInfos, IQueryable<T> query)
79.         where TOrderKey : struct, Enum
80.     {
81.         ArgumentNullException.ThrowIfNull(OrderInfos);
82.         ArgumentNullException.ThrowIfNull(query);
83.         if (OrderInfos.GetSupportedOrderKeySelectors()?.Count > 0 is false) throw new InvalidDataException($"{nameof(OrderInfos.GetSupportedOrderKeySelectors)}");
85.         IOrderedQueryable<T> orderedQuery;
86.         QueryableOrderMethod methodKind;
87.         MethodInfo orderMethod;
88.         Expression<Func<T, object?>> keySelector;
90.         var firstOrder = OrderInfos.OrderKeys?.FirstOrDefault();
91.         if (firstOrder is not null)
92.         {
93.             methodKind = firstOrder.OrderKind switch
94.             {
95.                 OrderKind.Asc => QueryableOrderMethod.OrderBy,
96.                 OrderKind.Desc => QueryableOrderMethod.OrderByDescending,
97.                 _ => throw new InvalidDataException($"{nameof(OrderKind)}"),
98.             };
100.             keySelector = OrderInfos.GetSupportedOrderKeySelectors()[firstOrder.Key];
101.             orderMethod = GetQueryOrderMethod<T>(methodKind, keySelector.ReturnType);
102.             orderedQuery = (IOrderedQueryable<T>)orderMethod.Invoke(null, [query, keySelector])!;
103.         }
104.         else
105.         {
106.             keySelector = OrderInfos.GetSupportedOrderKeySelectors().First().Value;
107.             orderedQuery = (IOrderedQueryable<T>)(GetQueryOrderMethod<T>(QueryableOrderMethod.OrderBy, keySelector.ReturnType)
108.                 .Invoke(null, [query, keySelector]))!;
109.         }
111.         foreach (var subsequentOrder in OrderInfos.OrderKeys?.Skip(1) ?? [])
112.         {
113.             if (subsequentOrder is not null)
114.             {
115.                 methodKind = subsequentOrder.OrderKind switch
116.                 {
117.                     OrderKind.Asc => QueryableOrderMethod.ThenBy,
118.                     OrderKind.Desc => QueryableOrderMethod.ThenByDescending,
119.                     _ => throw new InvalidDataException($"{nameof(OrderKind)}"),
120.                 };
122.                 keySelector = OrderInfos.GetSupportedOrderKeySelectors()[subsequentOrder.Key];
123.                 orderMethod = GetQueryOrderMethod<T>(methodKind, keySelector.ReturnType);
124.                 orderedQuery = (IOrderedQueryable<T>)orderMethod.Invoke(null, [orderedQuery, keySelector])!;
125.             }
126.         }
128.         return orderedQuery;
129.     }
131.     private static MethodInfo GetQueryOrderMethod<T>(QueryableOrderMethod method, Type orderKeyType)
132.     {
133.         return method switch
134.         {
135.             QueryableOrderMethod.OrderBy => _queryableOederByOfT.MakeGenericMethod(typeof(T), orderKeyType),
136.             QueryableOrderMethod.OrderByDescending => _queryableOrderByDescendingOfT.MakeGenericMethod(typeof(T), orderKeyType),
137.             QueryableOrderMethod.ThenBy => _queryableThenByOfT.MakeGenericMethod(typeof(T), orderKeyType),
138.             QueryableOrderMethod.ThenByDescending => _queryableThenByDescendingOfT.MakeGenericMethod(typeof(T), orderKeyType),
139.             _ => throw new InvalidDataException($"{nameof(method)}"),
140.         };
141.     }
142. }

复制代码

基础查询定义

1. /// <summary>
2. /// 示例1
3. /// </summary>
4. public class Entity1
5. {
6.     public int Id { get; set; }
8.     public string? Text1 { get; set; }
10.     public Entity2? Entity2 { get; set; }
12.     public List<Entity3> Entities3 { get; set; } = [];
13. }
15. /// <summary>
16. /// 示例2
17. /// </summary>
18. public class Entity2
19. {
20.     public int Id { get; set; }
22.     public string? Text2 { get; set; }
23. }
25. /// <summary>
26. /// 示例3
27. /// </summary>
28. public class Entity3
29. {
30.     public int Id { get; set; }
32.     public string? Text3 { get; set; }
34.     public Entity1? Entity1 { get; set; }
35. }

复制代码

从示例中可以看出，只必要针对数据类型的基础数据利用标量过滤器类型实现基础筛选，对于引用的其他数据类型，可以直接复用引用类型的查询天生器，并利用由组合查询天生接口提供的组合方法即可主动把复杂类型的筛选条件嵌套到当前类型的属性上。
分页查询

1. /// <summary>
2. /// Entity1查询生成器
3. /// </summary>
4. /// <param name="Text1">Entity1文本</param>
5. /// <param name="Id">Entity1的Id</param>
6. /// <param name="Entity2">Entity1的Entity2筛选</param>
7. /// <param name="Entities3">Entity1的Entity3集合筛选</param>
8. /// <param name="Reverse">是否反转条件</param>
9. /// <inheritdoc cref="QueryBuilderBase{T}"/>
10. /// <remarks>
11. /// 反转条件由<see cref="QueryBuilderBase{T}"/>在<see cref="QueryBuilderBase{T}.GetWherePredicate()"/>中自动进行，此处不需要处理。
12. /// </remarks>
13. public sealed record Entity1QueryBuilder(
14.     NumberSearchFilter<int>? Id = null,
15.     StringSearchFilter? Text1 = null,
16.     Entity2QueryBuilder? Entity2 = null,
17.     CollectionMemberSearchFilter<Entity3QueryBuilder, Entity3>? Entities3 = null,
18.     [EnumDataType(typeof(PredicateCombineKind))]
19.     PredicateCombineKind? CombineType = PredicateCombineKind.And,
20.     bool Reverse = false)
21.     : QueryBuilderBase<Entity1>(CombineType)
22.     , IPredicateReversible
23. {
24.     /// <inheritdoc/>
25.     protected override Expression<Func<Entity1, bool>>? BuildWherePredicate()
26.     {
27.         List<Expression<Func<Entity1, bool>>> predicates = [];
29.         predicates.AddIfNotNull(Id?.GetWherePredicate<Entity1>(e1 => e1.Id));
30.         predicates.AddIfNotNull(Text1?.GetWherePredicate<Entity1>(e1 => e1.Text1!));
31.         predicates.AddIfNotNull(Entity2?.GetWherePredicate<Entity1>(e1 => e1.Entity2!));
32.         predicates.AddIfNotNull(Entities3?.GetWherePredicate<Entity1>(e1 => e1.Entities3));
33.         predicates.AddIfNotNull(base.BuildWherePredicate());
35.         var where = CombinePredicates(predicates);
37.         return where;
38.     }
39. }
41. /// <summary>
42. /// Entity2查询生成器
43. /// </summary>
44. /// <param name="Text2">Entity2文本</param>
45. /// <param name="Id">Entity2的Id</param>
46. /// <param name="Reverse">是否反转条件</param>
47. /// <inheritdoc cref="QueryBuilderBase{T}"/>
48. public sealed record Entity2QueryBuilder(
49.     NumberSearchFilter<int>? Id = null,
50.     StringSearchFilter? Text2 = null,
51.     [EnumDataType(typeof(PredicateCombineKind))]
52.     PredicateCombineKind? CombineType = PredicateCombineKind.And,
53.     bool Reverse = false)
54.     : QueryBuilderBase<Entity2>(CombineType)
55.     , IPredicateReversible
56. {
57.     /// <inheritdoc/>
58.     protected override Expression<Func<Entity2, bool>>? BuildWherePredicate()
59.     {
60.         List<Expression<Func<Entity2, bool>>> predicates = [];
62.         predicates.AddIfNotNull(Id?.GetWherePredicate<Entity2>(e1 => e1.Id));
63.         predicates.AddIfNotNull(Text2?.GetWherePredicate<Entity2>(e2 => e2.Text2!));
64.         predicates.AddIfNotNull(base.BuildWherePredicate());
66.         var where = CombinePredicates(predicates);
68.         return where;
69.     }
70. }
72. /// <summary>
73. /// Entity3查询生成器
74. /// </summary>
75. /// <param name="Text3">Entity3文本</param>
76. /// <param name="Entity1">Entity3的Entity1筛选</param>
77. /// <param name="Id">Entity3的Id</param>
78. /// <param name="Reverse">是否反转条件</param>
79. /// <inheritdoc cref="QueryBuilderBase{T}"/>
80. public sealed record Entity3QueryBuilder(
81.     NumberSearchFilter<int>? Id = null,
82.     StringSearchFilter? Text3 = null,
83.     Entity1QueryBuilder? Entity1 = null,
84.     [EnumDataType(typeof(PredicateCombineKind))]
85.     PredicateCombineKind? CombineType = PredicateCombineKind.And,
86.     bool Reverse = false)
87.     : QueryBuilderBase<Entity3>(CombineType)
88.     , IPredicateReversible
89. {
90.     /// <inheritdoc/>
91.     protected override Expression<Func<Entity3, bool>>? BuildWherePredicate()
92.     {
93.         List<Expression<Func<Entity3, bool>>> predicates = [];
95.         predicates.AddIfNotNull(Id?.GetWherePredicate<Entity3>(e3 => e3.Id));
96.         predicates.AddIfNotNull(Text3?.GetWherePredicate<Entity3>(e3 => e3.Text3!));
97.         predicates.AddIfNotNull(Entity1?.GetWherePredicate<Entity3>(e3 => e3.Entity1!));
98.         predicates.AddIfNotNull(base.BuildWherePredicate());
100.         var where = CombinePredicates(predicates);
102.         return where;
103.     }
104. }
106. public static class CollectionExtensions
107. {
108.     /// <summary>
109.     /// 如果<paramref name="item"/>不是<see langword="null"/>，把<paramref name="item"/>添加到<paramref name="collection"/>。
110.     /// </summary>
111.     /// <typeparam name="T">集合的元素类型。</typeparam>
112.     /// <param name="collection">待添加元素的集合。</param>
113.     /// <param name="item">要添加的元素。</param>
114.     /// <returns>是否成功把元素添加到集合。</returns>
115.     [MethodImpl(MethodImplOptions.AggressiveInlining)]
116.     public static bool AddIfNotNull<T>(this ICollection<T> collection, T? item)
117.     {
118.         ArgumentNullException.ThrowIfNull(collection, nameof(collection));
120.         if (item is not null)
121.         {
122.             collection.Add(item);
123.             return true;
124.         }
126.         return false;
127.     }
128. }

复制代码

分页查询只要利用之前定义好的泛型基类填充类型参数即可。由于实例类型必要实现关键字排序，因此要实现干系接口。
高级分页查询

1. /// <summary>
2. /// Entity1分页查询生成器
3. /// </summary>
4. /// <inheritdoc cref="OffsetPagedQueryBuilder{TQueryBuilder, T2}"/>
5. public sealed record OffsetPagedEntity1QueryBuilder(
6.     Entity1QueryBuilder Query,
7.     OffsetPageInfo? OffsetPage = null,
8.     ImmutableList<OrderInfo<Entity1OrderKey>>? OrderKeys = null)
9.     : OffsetPagedQueryBuilder<Entity1QueryBuilder, Entity1>(Query, OffsetPage)
10.     , IKeySelectorOrderedQueryBuilder<Entity1, Entity1OrderKey>
11. {
12.     /// <inheritdoc/>
13.     public IReadOnlyDictionary<Entity1OrderKey, Expression<Func<Entity1, object?>>> GetSupportedOrderKeySelectors() => Entity1OrderKeySelector.Content;
15.     /// <inheritdoc/>
16.     public override IOrderedQueryable<Entity1> ApplyOrder(IQueryable<Entity1> query) => this.ApplyKeyedOrder(query);
17. }
19. /// <summary>
20. /// Entity1排序关键字
21. /// </summary>
22. public enum Entity1OrderKey : uint
23. {
24.     /// <summary>
25.     /// Id
26.     /// </summary>
27.     Id = 1,
29.     /// <summary>
30.     /// Text1
31.     /// </summary>
32.     Text1
33. }
35. internal static class Entity1OrderKeySelector
36. {
37.     public static IReadOnlyDictionary<Entity1OrderKey, Expression<Func<Entity1, object?>>> Content { get; } =
38.         FrozenDictionary.ToFrozenDictionary<Entity1OrderKey, Expression<Func<Entity1, object?>>>([
39.             new(Entity1OrderKey.Id, e1 => e1.Id),
40.             new(Entity1OrderKey.Text1, e1 => e1.Text1),
41.         ]);
42. }

复制代码

高级分页查询同样只必要填充预定义泛型基类的类型参数即可。
实例化查询天生器对象

1. /// <summary>
2. /// Entity1分页高级查询生成器
3. /// </summary>
4. /// <param name="OrderKeys">排序信息</param>
5. /// <inheritdoc cref="OffsetPagedQueryBuilder{TQueryBuilder, T}"/>
6. public sealed record OffsetPagedAdvancedEntity1QueryBuilder(
7.     AdvancedQueryBuilder<Entity1QueryBuilder, Entity1> Query,
8.     ImmutableList<OrderInfo<Entity1OrderKey>>? OrderKeys = null,
9.     OffsetPageInfo? OffsetPage = null)
10.     : OffsetPagedQueryBuilder<AdvancedQueryBuilder<Entity1QueryBuilder, Entity1>, Entity1>(
11.         Query,
12.         OffsetPage)
13.     , IKeySelectorOrderedQueryBuilder<Entity1, Entity1OrderKey>
14. {
15.     /// <inheritdoc/>
16.     public IReadOnlyDictionary<Entity1OrderKey, Expression<Func<Entity1, object?>>> GetSupportedOrderKeySelectors() => Entity1OrderKeySelector.Content;
18.     /// <inheritdoc/>
19.     public override IOrderedQueryable<Entity1> ApplyOrder(IQueryable<Entity1> query) => this.ApplyKeyedOrder(query);
20. }

复制代码

在集合中利用天生器

1. OffsetPagedAdvancedEntity1QueryBuilder queryBuilder =
2.     new OffsetPagedAdvancedEntity1QueryBuilder(
3.         Query: new AdvancedQueryBuilder<Entity1QueryBuilder, Entity1>(
4.             Queries: [ // ImmutableList<Entity1QueryBuilder>
5.                 new Entity1QueryBuilder (
6.                     Id: new NumberSearchFilter<int>([2], ComparableNumberSearchOperator.GreaterThan),
7.                     Text1: new StringSearchFilter(["aa"], StringSearchOperator.Contains),
8.                     Entity2: new Entity2QueryBuilder(
9.                         new NumberSearchFilter<int>([100]),
10.                         new StringSearchFilter(["ccc"])
11.                     ),
12.                     Entities3: null,
13.                     CombineType: PredicateCombineKind.Or,
14.                     Reverse: false
15.                 ),
16.                 new Entity1QueryBuilder(
17.                     Id: new NumberSearchFilter<int>([5], ComparableNumberSearchOperator.LessThan)
18.                 )
19.             ],
20.             QueryGroups: [ // ImmutableList<AdvancedQueryBuilder<Entity1QueryBuilder, Entity1>>
21.                 new AdvancedQueryBuilder<Entity1QueryBuilder, Entity1>(
22.                     Queries: [ // ImmutableList<Entity1QueryBuilder>
23.                         new Entity1QueryBuilder(
24.                             Id: new NumberSearchFilter<int>([20], ComparableNumberSearchOperator.Equal),
25.                             Text1: new StringSearchFilter(["bb"], StringSearchOperator.Contains),
26.                             Entity2: null,
27.                             Entities3: new CollectionMemberSearchFilter<Entity3QueryBuilder, Entity3>(
28.                                 query: new Entity3QueryBuilder(
29.                                     Id: null,
30.                                     Text3: new StringSearchFilter(["fff"], StringSearchOperator.StartsWith)
31.                                 ),
32.                                 count: new NumberSearchFilter < int >([50]),
33.                                 percent: null,
34.                                 reverse: false
35.                             ),
36.                             CombineType: PredicateCombineKind.And,
37.                             Reverse: false
38.                         )
39.                     ],
40.                     QueryGroups:[ // ImmutableList<AdvancedQueryBuilder<Entity1QueryBuilder, Entity1>>
41.                     ],
42.                     CombineType: PredicateCombineKind.Or,
43.                     Reverse: true
44.                 )
45.             ],
46.             CombineType: PredicateCombineKind.And,
47.             Reverse: true
48.         ),
49.         OrderKeys: [ // ImmutableList<OrderInfo<Entity1OrderKey>>
50.             new OrderInfo<Entity1OrderKey>(Entity1OrderKey.Text1, OrderKind.Desc),
51.             new OrderInfo<Entity1OrderKey>(Entity1OrderKey.Id),
52.         ],
53.         OffsetPage: new OffsetPageInfo(1,20)
54.     );

复制代码

最终得到的筛选表达式

1. // 准备一个集合
2. var entity1Arr = new Entity1[
3.         new()
4.     ];
5. // 从生成器中获取筛选表达式
6. var where = queryBuilder.GetWherePredicate();
7. // 把集合转换为 IQueryable<Entity1> 使用表达式类型的参数
8. var query = entity1Arr.AsQueryable().Where(where!);
9. // 把排序应用到查询
10. var ordered = builder.ApplyOrder(query);
11. // 把分页应用到查询
12. var paged = builder.OffsetPage(ordered);
13. // 把表达式编译为委托
14. var whereFunc = where.Compile();

复制代码

这个表达式是经过手动去除多余的括号，重新整理缩进后得到的版本。原始表达式像这样：

在此也保举这个好用的VS插件：ReadableExpressions.Visualizers。这个插件可以把表达式显示成代码编辑器里的样子，对各种语法要素也会着色，调试动态拼接的表达式时非常好用。
EF Core天生的SQL(SQL Server)

1. Expression<Func<Entity1, bool>> exp = e1 =>
2. !(
3.     (
4.         e1.Id > 2
5.         || e1.Text1.Contains("aa")
6.         || (e1.Entity2.Id == 100 && e1.Entity2.Text2.Contains("ccc"))
7.     )
8.     && e1.Id < 5
9.     && !(
10.         e1.Id == 20
11.         && e1.Text1.Contains("bb")
12.         && e1.Entities3.AsQueryable().Count() == 50
13.     )
14. );

复制代码

等价的JSON表示

1. DECLARE @__p_0 int = 0;
2. DECLARE @__p_1 int = 20;
4. SELECT [e].[Id], [e].[Entity2Id], [e].[Text1]
5. FROM [Entity1] AS [e]
6. LEFT JOIN [Entity2] AS [e0] ON [e].[Entity2Id] = [e0].[Id]
7. WHERE ([e].[Id] <= 2 AND ([e].[Text1] NOT LIKE N'%aa%' OR [e].[Text1] IS NULL) AND ([e0].[Id] <> 100 OR [e0].[Id] IS NULL OR [e0].[Text2] NOT LIKE N'%ccc%' OR [e0].[Text2] IS NULL)) OR [e].[Id] >= 5 OR ([e].[Id] = 20 AND [e].[Text1] LIKE N'%bb%' AND (
8.     SELECT COUNT(*)
9.     FROM [Entity3] AS [e1]
10.     WHERE [e].[Id] = [e1].[Entity1Id]) = 50)
11. ORDER BY [e].[Text1] DESC, [e].[Id]
12. OFFSET @__p_0 ROWS FETCH NEXT @__p_1 ROWS ONLY

复制代码

JSON中的属性如果是类型定义时的默认值，可以省略不写。比方字符串搜刮的默认操纵是包含子串，条件反转的默认值是false等。
特点总结

这套查询天生器是一个完全可组合的结构。从一组内置基础类型的筛选器开始组合出基层自定义类型的天生器，再通过基础筛选器和自定义天生器的组合继续组合出具有嵌套结构的类型的筛选器，末了通过泛型的分页和高级查询天生器组合出完整的查询天生器。这些查询天生器也可以独立利用，自由度很高。比方分页查询的总数计算，就可以只提取其中的筛选表达式部分来用，其中的各种自定义筛选器也都可以当作顶层筛选器来用。
基础类型的筛选器只实现组合天生器接口，因为基础类型一定是作为其他类型的属性来用的，所以针对基础类型的条件也一定要嫁接到一个属性访问表达式上才有意义。对于自定义表达式天生器，当作为顶级类型来利用时，体现为直接天生器，以当前类型为目标天生表达式；当作为其他类型的属性时，又体现为组合天生器，把天生的条件嫁接到上层对象的属性上。
筛选器的各个属性名和作用目标属性名完全无关，这样既隔离了内部代码和外部查询，使两边互不干扰，也能轻松对外部查询隐藏内部名称，降低安全风险。由于每个可查询的属性都是明确定义的，因此完全不存在恶意攻击的可能性，如果想对参数的范围之类的信息进行审查，结构化的查询数据也非常容易操纵。从查询天生的定义中可以看出，查询的每一个片断都是静态表达式，因此天生器的所有部分都完全兼容静态编译检查和主动重构。
这个查询天生器解决了System.Linq.Dynamic.Core和LinqKit的劣势，相比较可能唯一的不便之处是代码量稍大，等价的JSON表示内容量较大，但是就因此获得的组合灵活性、序列化传输兼容性和静态安全性而言，这点代价还是可以担当的。
为了淘汰复杂查询的必要，笔者把查询关键字筹划为数组类型，再根据操纵检查具体数据。比方候选项查询，如果不直接支持，就只能利用高级查询天生器的基础天生器数组之间的Or连接来模拟。既然候选项查询必须利用数组型关键字，干脆充分利用这个数组的特点，直接提供区间查询，多个不连续区间查询等功能，最大程度淘汰对高级查询天生器的依靠，尽可能在简单查询天生器里实现绝大部分常见条件。
如果直接把表达式编译成委托来用的话，可能会出现空引用异常，因为表达式不支持空传播运算符，只能直接访问。用EF Core天生SQL不会出现问题。
结语

好久以前笔者就思考过，利用LINQ实现动态表达式天生应该怎么办。刚开始发现JqGrid这个表格组件支持嵌套的复杂条件，并以嵌套的JSON结构来表示。后来又赞叹于了HotChocolate的主动条件参数天生和架构修改配置。开始思考动态天生的问题后又先后研究了System.Linq.Dynamic.Core和LinqKit等方案，分析总结了他们的特点和优劣。几经周折终于实现了这个比较满意表达式天生器。
像平凡表达式天生器接口和组合表达式天生器接口就是研究过程中发现应该是两个差别的功能和接谈锋分离出来的。对于基础类型天生器，一定要嫁接到到其他类型的属性上才有效。而对于分页天生器来说又没有可组合的必要，要分页就说明应该是以顶级类型的身份来用。对于自定义类型的天生器来说又是两种都有可能。这样随着研究的深入问题逐步清晰的环境经常出现，而且构思阶段很难发现。
最开始分页天生器是没有通用泛型类的，必要自己继承，但是用了一段时间发现这个东西形态固定，实际上可以用泛型类实现。主动化条件反转和防止重复反转也是后来才发现息争决。
这次研究能顺利进行下去的一个关键是想到了对于复杂嵌套类型，可以把完整的条件表达式拆分为从顶级类型到目标类型的访问表达式和针对目标类型的条件表达式作为两个独立的部分来处理，然后利用表达式访问器拼合两个部分。这样使得天生器和数据类型一样可以自由组合。嵌套的表达式天生问题曾一直困扰着笔者，直到弄懂了表达式访问器的用法和打通了思路。
经过这次研究，对表达式的利用也更加熟练，收获颇丰。接待园友体验交流。
QQ群

读者交流QQ群：540719365

接待读者和广大朋侪一起交流，如发现本书错误也接待通过博客园、QQ群等方式告知笔者。
本文地址：如安在 .NET 中构建一个好用的动态查询天生器

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。