コード例 #1
0
        public void T3()
        {
            // a => a.Test1

            var classToBeFiltered = new ClassToBeFiltered();
            var a      = Expression.Parameter(classToBeFiltered.GetType(), "a");
            var body   = Expression.Property(a, "Test1");
            var lambda = Expression.Lambda <Func <ClassToBeFiltered, int> >(body, a);

            lambda.ToString()
            .Should()
            .Be("a => a.Test1");
        }
コード例 #2
0
        public void TheProblem()
        {
            var request = new Request
            {
                Filters = new List <Filter>
                {
                    new Filter
                    {
                        Field      = "Test1",
                        Value      = "1",
                        FilterType = FilterTypes.Gt
                    },
                    new Filter
                    {
                        Field      = "Test2",
                        Value      = "2",
                        FilterType = FilterTypes.Lt
                    }
                }
            };

            // ??

            // x.Test1 > 1
            // x.Test2 < 2
            // x => x.Test1 > 1 AndAlso x.Test2 < 2

            var x = Expression.Parameter(typeof(ClassToBeFiltered), "x");

            Expression expression = null;

            foreach (var filter in request.Filters)
            {
                if (expression == null)
                {
                    expression = GetExpression <ClassToBeFiltered>(filter, x);
                }
                else
                {
                    if (request.LogicalOperator == LogicalOperator.And)
                    {
                        expression = Expression.AndAlso(expression, GetExpression <ClassToBeFiltered>(filter, x));
                    }
                    else
                    {
                        expression = Expression.Or(expression, GetExpression <ClassToBeFiltered>(filter, x));
                    }
                }
            }

            var ok = new ClassToBeFiltered {
                Test1 = 2, Test2 = 0
            };
            var classToBeFiltereds = new List <ClassToBeFiltered> {
                ok, new ClassToBeFiltered {
                    Test1 = 0, Test2 = 3
                }
            }.AsQueryable();

            classToBeFiltereds.Where(Expression.Lambda <Func <ClassToBeFiltered, bool> >(expression, x))
            .ToList()
            .Should()
            .BeEquivalentTo(new List <ClassToBeFiltered> {
                ok
            });

//            Convert.ChangeType()
            // Expression
            // Expression z Filter0 AndAlso Expression z Filter1
            // ClassToBeFilter jest obiektem na którym ma działać filtr
            // Test1 odwoluje sie do property Test1 z ClassToBeFiltered itd.
            // List<ClassToFiltered>().AsQueryable().Where(WynikNaszejOperacji);

            // Metoda przyjmuje filter, zwraca expression
            // Zamiast Filter0, Filter1 -> Lista filtrów, request ma mieć listę filtrów
            // Sprawdzenie czy field rzeczywiście istnieje przed stworzniem filtra - OK
            // atrybut, który mówi, czy property jest filtrowalne - OK
            // spróbować stworzyć filtr "Contains", "StartsWith" -> to ma działać tylko na stringach - troszkę google'a
            // ^ => Expression.Call(...)
            // request zawiera property z informacją, o tym czy filtry mają być łączone andem czy orem
        }