ExpressionExtensions.cs
7.78 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
using NCC.Dependency;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
namespace NCC.LinqBuilder
{
/// <summary>
/// 表达式拓展类
/// </summary>
[SuppressSniffer]
public static class ExpressionExtensions
{
/// <summary>
/// 组合两个表达式
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="extendExpression">表达式2</param>
/// <param name="mergeWay">组合方式</param>
/// <returns>新的表达式</returns>
public static Expression<TSource> Compose<TSource>(this Expression<TSource> expression, Expression<TSource> extendExpression, Func<Expression, Expression, Expression> mergeWay)
{
var parameterExpressionSetter = expression.Parameters
.Select((u, i) => new { u, Parameter = extendExpression.Parameters[i] })
.ToDictionary(d => d.Parameter, d => d.u);
var extendExpressionBody = ParameterReplaceExpressionVisitor.ReplaceParameters(parameterExpressionSetter, extendExpression.Body);
return Expression.Lambda<TSource>(mergeWay(expression.Body, extendExpressionBody), expression.Parameters);
}
/// <summary>
/// 与操作合并两个表达式
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="extendExpression">表达式2</param>
/// <returns>新的表达式</returns>
public static Expression<Func<TSource, bool>> And<TSource>(this Expression<Func<TSource, bool>> expression, Expression<Func<TSource, bool>> extendExpression)
{
return expression.Compose(extendExpression, Expression.AndAlso);
}
/// <summary>
/// 与操作合并两个表达式，支持索引器
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="extendExpression">表达式2</param>
/// <returns>新的表达式</returns>
public static Expression<Func<TSource, int, bool>> And<TSource>(this Expression<Func<TSource, int, bool>> expression, Expression<Func<TSource, int, bool>> extendExpression)
{
return expression.Compose(extendExpression, Expression.AndAlso);
}
/// <summary>
/// 根据条件成立再与操作合并两个表达式
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="condition">布尔条件</param>
/// <param name="extendExpression">表达式2</param>
/// <returns>新的表达式</returns>
public static Expression<Func<TSource, bool>> AndIf<TSource>(this Expression<Func<TSource, bool>> expression, bool condition, Expression<Func<TSource, bool>> extendExpression)
{
return condition ? expression.Compose(extendExpression, Expression.AndAlso) : expression;
}
/// <summary>
/// 根据条件成立再与操作合并两个表达式，支持索引器
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="condition">布尔条件</param>
/// <param name="extendExpression">表达式2</param>
/// <returns>新的表达式</returns>
public static Expression<Func<TSource, int, bool>> AndIf<TSource>(this Expression<Func<TSource, int, bool>> expression, bool condition, Expression<Func<TSource, int, bool>> extendExpression)
{
return condition ? expression.Compose(extendExpression, Expression.AndAlso) : expression;
}
/// <summary>
/// 或操作合并两个表达式
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="extendExpression">表达式2</param>
/// <returns>新的表达式</returns>
public static Expression<Func<TSource, bool>> Or<TSource>(this Expression<Func<TSource, bool>> expression, Expression<Func<TSource, bool>> extendExpression)
{
return expression.Compose(extendExpression, Expression.OrElse);
}
/// <summary>
/// 或操作合并两个表达式，支持索引器
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="extendExpression">表达式2</param>
/// <returns>新的表达式</returns>
public static Expression<Func<TSource, int, bool>> Or<TSource>(this Expression<Func<TSource, int, bool>> expression, Expression<Func<TSource, int, bool>> extendExpression)
{
return expression.Compose(extendExpression, Expression.OrElse);
}
/// <summary>
/// 根据条件成立再或操作合并两个表达式
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="condition">布尔条件</param>
/// <param name="extendExpression">表达式2</param>
/// <returns>新的表达式</returns>
public static Expression<Func<TSource, bool>> OrIf<TSource>(this Expression<Func<TSource, bool>> expression, bool condition, Expression<Func<TSource, bool>> extendExpression)
{
return condition ? expression.Compose(extendExpression, Expression.OrElse) : expression;
}
/// <summary>
/// 根据条件成立再或操作合并两个表达式，支持索引器
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式1</param>
/// <param name="condition">布尔条件</param>
/// <param name="extendExpression">表达式2</param>
/// <returns>新的表达式</returns>
public static Expression<Func<TSource, int, bool>> OrIf<TSource>(this Expression<Func<TSource, int, bool>> expression, bool condition, Expression<Func<TSource, int, bool>> extendExpression)
{
return condition ? expression.Compose(extendExpression, Expression.OrElse) : expression;
}
/// <summary>
/// 获取Lambda表达式属性名，只限 u=>u.Property 表达式
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="expression">表达式</param>
/// <returns>属性名</returns>
public static string GetExpressionPropertyName<TSource>(this Expression<Func<TSource, object>> expression)
{
if (expression.Body is UnaryExpression unaryExpression)
{
return ((MemberExpression)unaryExpression.Operand).Member.Name;
}
else if (expression.Body is MemberExpression memberExpression)
{
return memberExpression.Member.Name;
}
else if (expression.Body is ParameterExpression parameterExpression)
{
return parameterExpression.Type.Name;
}
throw new InvalidCastException(nameof(expression));
}
/// <summary>
/// 是否是空集合
/// </summary>
/// <typeparam name="TSource">泛型类型</typeparam>
/// <param name="sources">集合对象</param>
/// <returns>是否为空集合</returns>
public static bool IsNullOrEmpty<TSource>(this IEnumerable<TSource> sources)
{
return sources == null || !sources.Any();
}
}
}