private object Eval(string expression, Parameter[] pars)
        {
            Delegate lambda;

            if (!_lambdaCache.TryGetValue(expression, out lambda))
            {
                var parameters = pars.Select(p => p.ParameterExpression).ToArray();
                lambda = DynamicExpression.ParseLambda(parameters, typeof(object), expression, _variables).Compile();

                _lambdaCache.Add(expression, lambda);
            }

            return(lambda.DynamicInvoke(pars.Select(p => p.Value).ToArray()));
        }
Esempio n. 2
0
        public SubtotalSummaryFunc GetFunc()
        {
            var func = new SubtotalSummaryFunc(Name, Column);

            if (HasParameter("Over"))
            {
                func.GetExpression = type =>
                {
                    var par = Expression.Parameter(type, "item");
                    return(DynamicExpression.ParseLambda(new[] { par }, null, GetParameter("Over")));
                }
            }
            ;
            func.DataSource = DataSource;
            return(func);
        }
    }
        public void ExpressionParseTest()
        {
            var customers = new Customer[]
            {
                new Customer {
                    Id = 1, Name = "Customer1"
                },
                new Customer {
                    Id = 2, Name = "Customer2"
                }
            }.AsEnumerable();

            string query  = "customers.Where(c => (c.Id = 1)).OrderBy(c=>(c.Name)).Select(c=>(c))";
            var    lambda = DynamicExpression.ParseLambda(new [] { Expression.Parameter(customers.GetType(), "customers") }, null, query);
            var    dlg    = lambda.Compile();

            dlg.DynamicInvoke(customers).Should().BeAssignableTo <IEnumerable <Customer> >();
            ((IEnumerable <Customer>)dlg.DynamicInvoke(customers)).Should().HaveCount(1);
            ((IEnumerable <Customer>)dlg.DynamicInvoke(customers)).First().Id.Should().Be(1);
        }