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]); }