我刚刚成功地测试了这段代码多达 1,000,000 个条件而没有堆栈溢出 - 我怀疑它可以处理你想要的尽可能多的条件。
当Compile
在 lambda 表达式上调用时,表达式树会递归地向下遍历以编译它;极深的树(像这样)需要大量的堆栈帧来完成 - 因此StackOverflowException
.
我在下面所做的是MaxPredicateConditionCount
在编译表达式并将其推送到已经生成的条件集合之前只接受固定数量的条件(由 设置)。如果该预生成表达式的集合达到该最大值,则将它们组合成一个新的表达式,依此类推。通过这种方式,我们可以限制编译表达式所需的递归深度(通过分段执行)。
public class PredicateBuilder<TParameter>
{
private const int MaxPredicateConditionCount = 500;
private readonly List<Expression<Func<TParameter, bool>>> _existingPredicates = new List<Expression<Func<TParameter, bool>>>(MaxPredicateConditionCount);
private readonly ParameterExpression _parameter = Expression.Parameter(typeof(TParameter));
private Expression<Func<TParameter, bool>> _expression;
private Expression _workingPredicate;
private int _workingPredicateConditionCount;
public bool Built { get; private set; }
public Expression<Func<TParameter, bool>> LambdaExpression
{
get
{
if (!Built)
{
return null;
}
return _expression;
}
}
public void AddCondition<TValue>(string propertyName, TValue value)
{
if (Built)
{
throw new InvalidOperationException("Predicate has already been built");
}
var property = Expression.Property(_parameter, propertyName);
var constant = Expression.Constant(value, typeof(TValue));
var equality = Expression.Equal(property, constant);
if (_workingPredicate == null)
{
_workingPredicate = equality;
}
else
{
if (MaxPredicateConditionCount < ++_workingPredicateConditionCount)
{
var compiledWorking = Expression.Lambda<Func<TParameter, bool>>(_workingPredicate, _parameter).Compile();
_existingPredicates.Add(p => compiledWorking(p));
if (_existingPredicates.Count + 1 > MaxPredicateConditionCount)
{
var compiled = BuildExistingPredicates().Compile();
_existingPredicates.Clear();
_existingPredicates.Add(p => compiled(p));
}
_workingPredicate = equality;
_workingPredicateConditionCount = 0;
}
else
{
_workingPredicate = Expression.OrElse(_workingPredicate, equality);
}
}
}
private Expression<Func<TParameter, bool>> BuildExistingPredicates()
{
Expression compileTemp = Expression.Invoke(_existingPredicates[0], _parameter);
for (var i = 1; i < _existingPredicates.Count; ++i)
{
var nextCall = Expression.Invoke(_existingPredicates[i], _parameter);
compileTemp = Expression.OrElse(compileTemp, nextCall);
}
return Expression.Lambda<Func<TParameter, bool>>(compileTemp, _parameter);
}
public void Build()
{
Built = true;
//There were no conditions, assume true
if (_workingPredicate == null)
{
_expression = x => true;
return;
}
_existingPredicates.Add(Expression.Lambda<Func<TParameter, bool>>(_workingPredicate, _parameter));
_expression = BuildExistingPredicates();
_existingPredicates.Clear();
_workingPredicate = null;
_workingPredicateConditionCount = 0;
}
public Func<TParameter, bool> Compile()
{
if (!Built)
{
Build();
}
return _expression.Compile();
}
}
示例实体
public class SomeEntity
{
public string OrderID { get; set; }
}
用法
class Program
{
static void Main()
{
var builder = new PredicateBuilder<SomeEntity>();
for (int i = 0; i < 1000000; i++) // Create 1,000,000 expressions
{
builder.AddCondition("OrderID", "42");
Console.Title = i.ToString();
}
builder.Compile();
}
}