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 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 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 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 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 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"
        }));
    }
Exemple #9
0
        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_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
            }
        }));
    }
    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"
            }
        }));
    }
    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();