public void GetExpression_CustomPredicate()
{
var foo = new Foo()
{
Name = "11"
};
var val = new Func <string, bool>(p1 => p1 == foo.Name);
var filter = new FilterKeyValueAction()
{
FieldKey = "Name", FieldValue = val, FilterAction = FilterAction.CustomPredicate
};
var invoker = filter.GetFilterLambda <Foo>().Compile();
Assert.True(invoker.Invoke(foo));
// Expression
Expression <Func <string, bool> > p1 = p => p == foo.Name;
filter.FieldValue = p1;
invoker = filter.GetFilterLambda <Foo>().Compile();
Assert.True(invoker.Invoke(foo));
filter.FieldValue = new object();
Assert.Throws <InvalidOperationException>(() => filter.GetFilterLambda <Foo>());
}
public void GetFilterFunc_Ok()
{
var filter = new FilterKeyValueAction();
var invoker = filter.GetFilterFunc <Foo>();
Assert.True(invoker(new Foo()));
}
/// <summary>
/// Override existing filter conditions
/// </summary>
public override async Task SetFilterConditionsAsync(IEnumerable <FilterKeyValueAction> conditions)
{
if (conditions.Any())
{
FilterKeyValueAction first = conditions.First();
if (first.FieldValue is string value)
{
Value1 = value;
}
else
{
Value1 = "";
}
Action1 = first.FilterAction;
if (conditions.Count() == 2)
{
Count = 1;
FilterKeyValueAction second = conditions.ElementAt(1);
if (second.FieldValue is string value2)
{
Value2 = value2;
}
else
{
Value2 = "";
}
Action1 = second.FilterAction;
Logic = second.FilterLogic;
}
}
await base.SetFilterConditionsAsync(conditions);
}
/// <summary>
/// 指定 FilterKeyValueAction 获取 Lambda 表达式
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="filter"></param>
/// <returns></returns>
public static Expression <Func <TItem, bool> > GetFilterLambda <TItem>(this FilterKeyValueAction filter)
{
Expression <Func <TItem, bool> > ret = t => true;
if (!string.IsNullOrEmpty(filter.FieldKey) && filter.FieldValue != null)
{
var prop = typeof(TItem).GetProperty(filter.FieldKey);
if (prop != null)
{
var p = Expression.Parameter(typeof(TItem));
var fieldExpression = Expression.Property(p, prop);
Expression eq = fieldExpression;
// 可为空类型转化为具体类型
if (prop.PropertyType.IsGenericType &&
prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
eq = Expression.Convert(fieldExpression, prop.PropertyType.GenericTypeArguments[0]);
}
eq = filter.GetExpression(eq);
ret = Expression.Lambda <Func <TItem, bool> >(eq, p);
}
}
return(ret);
}
public void FilterKeyValueAction_FieldKey_Null()
{
var filter = new FilterKeyValueAction();
var invoker = filter.GetFilterLambda <Foo>().Compile();
Assert.True(invoker.Invoke(new Foo()));
}
public void FilterKeyValueAction_SimpleFilterExpression_Exception()
{
var filter = new FilterKeyValueAction()
{
FieldKey = "Name", FieldValue = "Name"
};
Assert.Throws <InvalidOperationException>(() => filter.GetFilterLambda <Dummy>());
}
public void GetExpression_NotEqual()
{
var filter = new FilterKeyValueAction()
{
FieldKey = "Count", FieldValue = 1, FilterAction = FilterAction.NotEqual
};
var invoker = filter.GetFilterLambda <Foo>().Compile();
Assert.True(invoker.Invoke(new Foo()
{
Count = 2
}));
}
public void FilterKeyValueAction_SimpleFilterExpression()
{
var filter = new FilterKeyValueAction()
{
FieldKey = "Name", FieldValue = "Name"
};
var invoker = filter.GetFilterLambda <Foo>().Compile();
Assert.True(invoker.Invoke(new Foo()
{
Name = "Name"
}));
}
public void GetFilterLambda_Nullable()
{
var filters = new FilterKeyValueAction()
{
FieldKey = nameof(Foo.DateTime), FieldValue = DateTime.MinValue
};
var exp = filters.GetFilterLambda <Foo>();
Assert.True(exp.Compile().Invoke(new Foo()
{
DateTime = DateTime.MinValue
}));
}
public void GetFilterLambda_Enum()
{
var filters = new FilterKeyValueAction()
{
FieldKey = nameof(Dummy.Education), FieldValue = "Middel"
};
var exp = filters.GetFilterLambda <Dummy>();
Assert.True(exp.Compile().Invoke(new Dummy()
{
Education = EnumEducation.Middel
}));
}
public void GetExpression_NotContains()
{
var filter = new FilterKeyValueAction()
{
FieldKey = "Name", FieldValue = "test", FilterAction = FilterAction.NotContains
};
var invoker = filter.GetFilterLambda <Foo>().Compile();
Assert.True(invoker.Invoke(new Foo()
{
Name = "11"
}));
}
public void NullContains_Ok()
{
var dummy = new Dummy();
var filter = new FilterKeyValueAction();
filter.FieldKey = "Foo";
filter.FilterAction = FilterAction.Contains;
filter.FieldValue = "";
var invoker = filter.GetFilterLambda <Dummy>().Compile();
var ret = invoker.Invoke(dummy);
Assert.False(ret);
}
public void FilterKeyValueAction_ComplexFilterExpression_Nullable()
{
var filter = new FilterKeyValueAction()
{
FieldKey = "Foo.DateTime", FieldValue = DateTime.MinValue
};
var invoker = filter.GetFilterLambda <Dummy>().Compile();
Assert.True(invoker.Invoke(new Dummy()
{
Foo = new Foo()
{
DateTime = DateTime.MinValue
}
}));
}
public void FilterKeyValueAction_ComplexFilterExpression()
{
var filter = new FilterKeyValueAction()
{
FieldKey = "Foo.Name", FieldValue = "Name"
};
var invoker = filter.GetFilterLambda <Dummy>().Compile();
Assert.True(invoker.Invoke(new Dummy()
{
Foo = new Foo()
{
Name = "Name"
}
}));
}
private static Expression GetExpression(this FilterKeyValueAction filter, Expression left)
{
var right = Expression.Constant(filter.FieldValue);
return(filter.FilterAction switch
{
FilterAction.Equal => Expression.Equal(left, right),
FilterAction.NotEqual => Expression.NotEqual(left, right),
FilterAction.GreaterThan => Expression.GreaterThan(left, right),
FilterAction.GreaterThanOrEqual => Expression.GreaterThanOrEqual(left, right),
FilterAction.LessThan => Expression.LessThan(left, right),
FilterAction.LessThanOrEqual => Expression.LessThanOrEqual(left, right),
FilterAction.Contains => left.Contains(right),
FilterAction.NotContains => Expression.Not(left.Contains(right)),
_ => Expression.Empty()
});
public void FilterKeyValueAction_ComplexFilterExpression_Enum()
{
var filter = new FilterKeyValueAction()
{
FieldKey = "Cat.Education", FieldValue = "Middel"
};
var invoker = filter.GetFilterLambda <Dummy>().Compile();
Assert.True(invoker.Invoke(new Dummy()
{
Cat = new Cat()
{
Education = EnumEducation.Middel
}
}));
}
/// <summary>
/// Override existing filter conditions
/// </summary>
public override async Task SetFilterConditionsAsync(IEnumerable <FilterKeyValueAction> conditions)
{
if (conditions.Any())
{
var type = Nullable.GetUnderlyingType(Type) ?? Type;
FilterKeyValueAction first = conditions.First();
if (first.FieldValue != null && first.FieldValue.GetType() == type)
{
Value = first.FieldValue.ToString();
}
else
{
Value = "";
}
}
await base.SetFilterConditionsAsync(conditions);
}
/// <summary>
/// 指定 FilterKeyValueAction 获取 Lambda 表达式
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="filter"></param>
/// <returns></returns>
public static Expression <Func <TItem, bool> > GetFilterExpression <TItem>(this FilterKeyValueAction filter)
{
Expression <Func <TItem, bool> > ret = t => true;
if (!string.IsNullOrEmpty(filter.FieldKey))
{
var prop = typeof(TItem).GetProperty(filter.FieldKey);
if (prop != null && filter.FieldValue != null)
{
var p = Expression.Parameter(typeof(TItem));
var fieldExpression = Expression.Property(p, prop);
var eq = GetExpression(filter, fieldExpression);
ret = Expression.Lambda <Func <TItem, bool> >(eq, p);
}
}
return(ret);
}
private static Expression GetExpression(this FilterKeyValueAction filter, Expression left)
{
var right = Expression.Constant(filter.FieldValue);
return(filter.FilterAction switch
{
FilterAction.Equal => Expression.Equal(left, right),
FilterAction.NotEqual => Expression.NotEqual(left, right),
FilterAction.GreaterThan => Expression.GreaterThan(left, right),
FilterAction.GreaterThanOrEqual => Expression.GreaterThanOrEqual(left, right),
FilterAction.LessThan => Expression.LessThan(left, right),
FilterAction.LessThanOrEqual => Expression.LessThanOrEqual(left, right),
FilterAction.Contains => left.Contains(right),
FilterAction.NotContains => Expression.Not(left.Contains(right)),
FilterAction.CustomPredicate => filter.FieldValue switch
{
LambdaExpression t => Expression.Invoke(t, left),
Delegate _ => Expression.Invoke(right, left),
_ => throw new ArgumentException(nameof(FilterKeyValueAction.FieldValue))
},
public void GetExpression_LessThanOrEqual()
{
var filter = new FilterKeyValueAction()
{
FieldKey = "Count", FieldValue = 10, FilterAction = FilterAction.LessThanOrEqual
};
var invoker = filter.GetFilterLambda <Foo>().Compile();
Assert.True(invoker.Invoke(new Foo()
{
Count = 9
}));
Assert.True(invoker.Invoke(new Foo()
{
Count = 10
}));
Assert.False(invoker.Invoke(new Foo()
{
Count = 11
}));
}
/// <summary> /// 指定 FilterKeyValueAction 获取委托 /// </summary> /// <typeparam name="TItem"></typeparam> /// <param name="filter"></param> /// <returns></returns> public static Func <TItem, bool> GetFilterFunc <TItem>(this FilterKeyValueAction filter) => filter.GetFilterLambda <TItem>().Compile();
/// <summary>
/// 指定 FilterKeyValueAction 获取 Lambda 表达式
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="filter"></param>
/// <returns></returns>
public static Expression <Func <TItem, bool> > GetFilterLambda <TItem>(this FilterKeyValueAction filter)
{
Expression <Func <TItem, bool> > ret = t => true;
var type = typeof(TItem);
if (!string.IsNullOrEmpty(filter.FieldKey) && filter.FieldValue != null)
{
ret = filter.FieldKey.Contains(".") ? GetComplexFilterExpression() : GetSimpleFilterExpression();
}
return(ret);
Expression <Func <TItem, bool> > GetSimpleFilterExpression()
{
var prop = typeof(TItem).GetPropertyByName(filter.FieldKey) ?? throw new InvalidOperationException($"the model {type.Name} not found the property {filter.FieldKey}");;
if (prop != null)
{
var p = Expression.Parameter(type);
var fieldExpression = Expression.Property(p, prop);
Expression eq = fieldExpression;
// 可为空类型转化为具体类型
if (prop.PropertyType.IsGenericType &&
prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
eq = Expression.Convert(fieldExpression, prop.PropertyType.GenericTypeArguments[0]);
}
else if (prop.PropertyType.IsEnum && filter.FieldValue is string)
{
eq = Expression.Call(fieldExpression, prop.PropertyType.GetMethod("ToString", Array.Empty <Type>()) !);
}
eq = filter.GetExpression(eq);
ret = Expression.Lambda <Func <TItem, bool> >(eq, p);
}
return(ret);
}
Expression <Func <TItem, bool> > GetComplexFilterExpression()
{
var p = Expression.Parameter(type);
var propertyNames = filter.FieldKey.Split('.');
PropertyInfo?pInfo = null;
Expression? fieldExpression = null;
foreach (var name in propertyNames)
{
if (pInfo == null)
{
pInfo = typeof(TItem).GetPropertyByName(name) ?? throw new InvalidOperationException($"the model {type.Name} not found the property {name}");
fieldExpression = Expression.Property(p, pInfo);
}
else
{
pInfo = pInfo.PropertyType.GetPropertyByName(name) ?? throw new InvalidOperationException($"the model {pInfo.PropertyType.Name} not found the property {name}");
fieldExpression = Expression.Property(fieldExpression, pInfo);
}
}
// 可为空类型转化为具体类型
if (pInfo !.PropertyType.IsGenericType && pInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
fieldExpression = Expression.Convert(fieldExpression !, pInfo.PropertyType.GenericTypeArguments[0]);
}
