Пример #1
0
        public void AndIsShortcircuit()
        {
            IExpression falseexpr = new ConstantExpression(false);
            IExpression dividebyzero = new BinaryOperatorExpression(new ConstantExpression(1), new ConstantExpression(0), BinaryOperator.Divide);

            Assert.IsFalse((bool)(new BooleanExpression(falseexpr, dividebyzero, BooleanOperator.And)).Evaluate(null));
        }
Пример #2
0
        public Node Parse()
        {
            Expression curExpr = null;
            for (; ; ) {
                _tokens.MoveNext();
                Token t = _tokens.Current;

                switch (t.Kind) {
                    case TokenKinds.EOF:
                        return curExpr;
                    case TokenKinds.Operator:
                        if (curExpr == null) {
                            throw new SyntaxErrorException("expected value before operator");
                        }

                        curExpr = ActionExpression.Operator(((OperatorToken)t).DlrOperator,
                            curExpr,
                            (Expression)Parse());
                        break;
                    case TokenKinds.Constant:
                        curExpr = new ConstantExpression(((ConstantToken)t).Value);
                        break;
                }
            }
        }
Пример #3
0
        public void OrIsShortcircuit()
        {
            IExpression trueexpr = new ConstantExpression(true);
            IExpression dividebyzero = new BinaryOperatorExpression(new ConstantExpression(1), new ConstantExpression(0), BinaryOperator.Divide);

            Assert.IsTrue((bool)(new BooleanExpression(trueexpr, dividebyzero, BooleanOperator.Or)).Evaluate(null));
        }
Пример #4
0
        public void CreateNotExpression()
        {
            IExpression trueexpr = new ConstantExpression(true);
            NotExpression expression = new NotExpression(trueexpr);

            Assert.AreEqual(trueexpr, expression.Expression);
        }
Пример #5
0
        public void EvaluateNotExpression()
        {
            IExpression trueexpr = new ConstantExpression(true);
            IExpression falseexpr = new ConstantExpression(false);

            Assert.IsFalse((bool)(new NotExpression(trueexpr)).Evaluate(null));
            Assert.IsTrue((bool)(new NotExpression(falseexpr)).Evaluate(null));
        }
Пример #6
0
        public void SetVariable()
        {
            IExpression expression = new ConstantExpression(1);
            BindingEnvironment environment = new BindingEnvironment();
            ICommand command = new SetCommand("spam", expression);
            command.Execute(environment);

            Assert.AreEqual(1, environment.GetValue("spam"));
        }
Пример #7
0
        public void EvaluateOr()
        {
            IExpression trueexpr = new ConstantExpression(true);
            IExpression falseexpr = new ConstantExpression(false);

            Assert.IsTrue((bool)(new BooleanExpression(trueexpr, trueexpr, BooleanOperator.Or)).Evaluate(null));
            Assert.IsTrue((bool)(new BooleanExpression(trueexpr, falseexpr, BooleanOperator.Or)).Evaluate(null));
            Assert.IsTrue((bool)(new BooleanExpression(falseexpr, trueexpr, BooleanOperator.Or)).Evaluate(null));
            Assert.IsFalse((bool)(new BooleanExpression(falseexpr, falseexpr, BooleanOperator.Or)).Evaluate(null));
        }
Пример #8
0
        public void CreateBooleanExpression()
        {
            IExpression trueexpr = new ConstantExpression(true);
            IExpression falseexpr = new ConstantExpression(false);
            BooleanExpression expression = new BooleanExpression(trueexpr, falseexpr, BooleanOperator.Or);

            Assert.AreEqual(trueexpr, expression.Left);
            Assert.AreEqual(falseexpr, expression.Right);

            Assert.AreEqual(BooleanOperator.Or, expression.Operation);
        }
Пример #9
0
        public void ExecuteSetIndexCommandOnList()
        {
            var list = new List<object>() { 1, 2, 2 };
            IExpression targetExpression = new ConstantExpression(list);
            IExpression indexExpression = new ConstantExpression(2);
            IExpression valueExpression = new ConstantExpression(3);

            var command = new SetIndexCommand(targetExpression, indexExpression, valueExpression);
            command.Execute(null);

            Assert.AreEqual(3, list[2]);
        }
Пример #10
0
        public void CreateSetIndexCommand()
        {
            IExpression targetExpression = new ConstantExpression(1);
            IExpression indexExpression = new ConstantExpression(2);
            IExpression valueExpression = new ConstantExpression(3);

            var command = new SetIndexCommand(targetExpression, indexExpression, valueExpression);

            Assert.AreEqual(targetExpression, command.TargetExpression);
            Assert.AreEqual(indexExpression, command.IndexExpression);
            Assert.AreEqual(valueExpression, command.Expression);
        }
Пример #11
0
        public void ExecuteSetIndexCommandOnArray()
        {
            var array = new object[] { 1, 2, 2 };
            IExpression targetExpression = new ConstantExpression(array);
            IExpression indexExpression = new ConstantExpression(2);
            IExpression valueExpression = new ConstantExpression(3);

            var command = new SetIndexCommand(targetExpression, indexExpression, valueExpression);
            command.Execute(null);

            Assert.AreEqual(3, array[2]);
        }
Пример #12
0
        public void AConstant_ShouldReturnTheConstantValue()
        {
            // Arrange
            var expectedValue = 3;
            var sut = new ConstantExpression(expectedValue);

            // Act
            var actual = sut.Eval();

            // Assert
            Assert.AreEqual(expectedValue, actual);
        }
Пример #13
0
        public void CreateSetCommand()
        {
            IExpression expression = new ConstantExpression("bar");
            SetCommand command = new SetCommand("foo", expression);

            Assert.IsNotNull(command);
            Assert.IsNotNull(command.Target);
            Assert.IsNotNull(command.Expression);

            Assert.AreEqual("foo", command.Target);
            Assert.AreEqual(expression, command.Expression);
        }
Пример #14
0
        public void ExecuteSetIndexCommandOnDictionary()
        {
            var dictionary = new Hashtable();
            IExpression targetExpression = new ConstantExpression(dictionary);
            IExpression indexExpression = new ConstantExpression("foo");
            IExpression valueExpression = new ConstantExpression("bar");

            var command = new SetIndexCommand(targetExpression, indexExpression, valueExpression);
            command.Execute(null);

            Assert.AreEqual("bar", dictionary["foo"]);
        }
        /// <summary>
        /// Performs reverse-mode (adjoint) automatic differentiation 
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="dependentVariable"></param>
        /// <param name="independentVariables"></param>
        public static void Differentiate(BlockExpressionBuilder builder, 
            out IList<Expression> derivativeExpressions,
            VectorParameterExpression dependentVariable,
            params VectorParameterExpression[] independentVariables)
        {
            if (independentVariables.Length == 0)
            {
                derivativeExpressions = null;
                return;
            }

            var block = builder.ToBlock();
            // change the numbering of variables; arguments first, then locals
            List<int>[] jLookup;
            Function[] f;

            // we want a list of functions which can be unary or binary (in principle high order if it makes sense) and a look-up
            // each function is associated with a parameter, which is either an argument or a local
            // for each function index we return a list of the indices of the functions that reference the parameter
            GetFunctions(block, out f, out jLookup);

            int N = dependentVariable.Index;

            bool[] derivativeRequired; int[] derivativeExpressionIndex;
            IdentifyNeccesaryDerivatives(N, jLookup, independentVariables, out derivativeRequired, out derivativeExpressionIndex);

            // the list of operations needed to calculate the derivatives (*all* derivatives)
            derivativeExpressions = new Expression[independentVariables.Length];
            var dxNdx = new Expression[N + 1];
            dxNdx[N] = new ConstantExpression<double>(1.0);
            for (int i = N - 1; i >= 0; i--)
            {
                if (!derivativeRequired[i]) continue;
                // dxN / dxi
                // need to find all operation indices j such that p(j) contains i
                // that is, all functions that have xi as an argument (these must therefore have a higher index than i)
                VectorParameterExpression total = new ConstantExpression<double>(0);
                var xi = f[i].Parameter;
                //need sum of dfj/dxi dXN/dxj
                foreach (var j in jLookup[i])
                {
                    var fj = f[j];
                    var dfjdxi = Differentiate(fj, xi, builder); // dfj/dxi
                    var dXNdxj = dxNdx[j]; // dXN/dxj
                    var product = builder.AddProductExpression(dfjdxi, dXNdxj);
                    total = builder.AddAdditionExpression(total, product);
                }
                dxNdx[i] = total;
                int targetIndex = derivativeExpressionIndex[i];
                if (targetIndex != -1) derivativeExpressions[targetIndex] = total;
            }
        }
 /// <summary>
 /// Adds the specified constant expression.
 /// </summary>
 /// <param name="constantExpression">The constant expression.</param>
 /// <param name="exponent">The exponent.</param>
 public void Add(ConstantExpression constantExpression, double exponent)
 {
     var additionalConstant = Math.Pow(constantExpression.Constant, exponent);
     if (this.constantFlatIdentifierRepresentation == null)
     {
         this.constantFlatIdentifierRepresentation = new ConstantFlatIdentifierRepresentation(additionalConstant);
         this.additionalCount++;
     }
     else
     {
         this.constantFlatIdentifierRepresentation =
             new ConstantFlatIdentifierRepresentation(
                 this.constantFlatIdentifierRepresentation.Constant * additionalConstant);
     }
 }
Пример #17
0
        static void Main(string[] args)
        {
            IArithmeticVisitor visitor = new ConsoleArithmeticVisitor();

            IArithmeticExpression leftInnerNode = new ConstantExpression(39);
            IArithmeticExpression rightInnerNode = new ConstantExpression(13);

            IArithmeticExpression leftNode = new ConstantExpression(15);
            IArithmeticExpression rightNode = new SubtractionExpression(leftInnerNode, rightInnerNode);

            IArithmeticExpression rootNode = new MultiplicationExpression(leftNode, new BracketsExpression(rightNode));

            rootNode.Accept(visitor);

            Console.WriteLine();
        }
Пример #18
0
 protected override Expression VisitConstant(ConstantExpression c)
 {
     return base.VisitConstant(c);
 }
Пример #19
0
        public IQueryable <Product> SetWhere(IQueryable <Product> source)
        {
            // Queries
            if (queryParams.Queries != null && queryParams.Queries.Count() > 0)
            {
                ParameterExpression product = Expression.Parameter(typeof(Product));

                BinaryExpression GetQueries(IEnumerable <Query> queries)
                {
                    List <BinaryExpression> left  = new List <BinaryExpression>();
                    BinaryExpression        right = null;


                    foreach (Query query in queries)
                    {
                        // Auto
                        if (query.QueryType == QueryType.Auto)
                        {
                            // Browsed Products
                            if (query.IntValue == 1)
                            {
                                if (queryParams.Cookies == null || queryParams.Cookies.Count(x => x.Key == "browse") == 0)
                                {
                                    continue;
                                }

                                string browseCookie = queryParams.Cookies.Where(x => x.Key == "browse").Select(x => x.Value).SingleOrDefault();

                                if (browseCookie == null)
                                {
                                    continue;
                                }

                                List <int> productIds = browseCookie.Split(',').Select(x => Int32.Parse(x)).ToList();

                                PropertyInfo         productProperty = typeof(Product).GetProperty("Id");
                                MemberExpression     productId       = Expression.Property(product, productProperty);
                                ConstantExpression   values          = Expression.Constant(productIds);
                                MethodInfo           method          = productIds.GetType().GetMethod("Contains");
                                MethodCallExpression call            = Expression.Call(values, method, productId);
                                right = Expression.Equal(call, Expression.Constant(true));
                            }

                            // Related products
                            else if (query.IntValue == 2 && queryParams.ProductId > 0)
                            {
                                PropertyInfo       nicheProperty = typeof(Product).GetProperty("NicheId");
                                PropertyInfo       idProperty    = typeof(Product).GetProperty("Id");
                                MemberExpression   id            = Expression.Property(product, idProperty);
                                ConstantExpression productId     = Expression.Constant(queryParams.ProductId);
                                MemberExpression   nicheId       = Expression.Property(product, nicheProperty);
                                ConstantExpression value         = Expression.Constant(query.IntValues[0]);

                                right = Expression.AndAlso(Expression.Equal(nicheId, value), Expression.NotEqual(id, productId));
                            }
                        }


                        // Category
                        else if (query.QueryType == QueryType.Category)
                        {
                            PropertyInfo       categoryProperty1 = typeof(Product).GetProperty("Niche");
                            PropertyInfo       categoryProperty2 = categoryProperty1.PropertyType.GetProperty("Category");
                            PropertyInfo       categoryProperty3 = categoryProperty2.PropertyType.GetProperty("Id");
                            MemberExpression   niche             = Expression.Property(product, categoryProperty1);
                            MemberExpression   niche_Category    = Expression.Property(niche, categoryProperty2);
                            MemberExpression   niche_Category_Id = Expression.Property(niche_Category, categoryProperty3);
                            ConstantExpression value             = Expression.Constant(query.IntValue);
                            right = Expression.Equal(niche_Category_Id, value);
                        }


                        // Niche
                        else if (query.QueryType == QueryType.Niche)
                        {
                            if (query.IntValue > 0)
                            {
                                PropertyInfo       nicheProperty = typeof(Product).GetProperty("NicheId");
                                MemberExpression   nicheId       = Expression.Property(product, nicheProperty);
                                ConstantExpression value         = Expression.Constant(query.IntValue);
                                right = Expression.Equal(nicheId, value);
                            }
                            else
                            {
                                PropertyInfo       categoryProperty1 = typeof(Product).GetProperty("Niche");
                                PropertyInfo       categoryProperty2 = categoryProperty1.PropertyType.GetProperty("UrlId");
                                MemberExpression   niche             = Expression.Property(product, categoryProperty1);
                                MemberExpression   niche_Url_Id      = Expression.Property(niche, categoryProperty2);
                                ConstantExpression value             = Expression.Constant(query.StringValue);
                                right = Expression.Equal(niche_Url_Id, value);
                            }
                        }


                        // Product Rating
                        else if (query.QueryType == QueryType.ProductRating)
                        {
                            PropertyInfo       ratingProperty = typeof(Product).GetProperty("Rating");
                            MemberExpression   rating         = Expression.Property(product, ratingProperty);
                            ConstantExpression value          = Expression.Constant(query.DoubleValue);

                            if (query.ComparisonOperator == ComparisonOperatorType.Equal)
                            {
                                right = Expression.Equal(rating, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.NotEqual)
                            {
                                right = Expression.NotEqual(rating, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.GreaterThan)
                            {
                                right = Expression.GreaterThan(rating, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.GreaterThanOrEqual)
                            {
                                right = Expression.GreaterThanOrEqual(rating, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.LessThan)
                            {
                                right = Expression.LessThan(rating, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.LessThanOrEqual)
                            {
                                right = Expression.LessThanOrEqual(rating, value);
                            }
                        }


                        // Product Price
                        else if (query.QueryType == QueryType.ProductPrice)
                        {
                            PropertyInfo       priceProperty1 = typeof(Product).GetProperty("MinPrice");
                            PropertyInfo       priceProperty2 = typeof(Product).GetProperty("MaxPrice");
                            MemberExpression   minPrice       = Expression.Property(product, priceProperty1);
                            MemberExpression   maxPrice       = Expression.Property(product, priceProperty2);
                            ConstantExpression zero           = Expression.Constant(0.0);
                            ConstantExpression value          = Expression.Constant(query.DoubleValue);

                            if (query.ComparisonOperator == ComparisonOperatorType.Equal)
                            {
                                right = Expression.OrElse(Expression.AndAlso(Expression.Equal(maxPrice, zero), Expression.Equal(minPrice, value)), Expression.Equal(maxPrice, value));
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.NotEqual)
                            {
                                right = Expression.OrElse(Expression.AndAlso(Expression.Equal(maxPrice, zero), Expression.NotEqual(minPrice, value)), Expression.NotEqual(maxPrice, value));
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.GreaterThan)
                            {
                                right = Expression.OrElse(Expression.AndAlso(Expression.Equal(maxPrice, zero), Expression.GreaterThan(minPrice, value)), Expression.GreaterThan(maxPrice, value));
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.GreaterThanOrEqual)
                            {
                                right = Expression.OrElse(Expression.AndAlso(Expression.Equal(maxPrice, zero), Expression.GreaterThanOrEqual(minPrice, value)), Expression.GreaterThanOrEqual(maxPrice, value));
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.LessThan)
                            {
                                right = Expression.OrElse(Expression.AndAlso(Expression.Equal(maxPrice, zero), Expression.LessThan(minPrice, value)), Expression.LessThan(maxPrice, value));
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.LessThanOrEqual)
                            {
                                right = Expression.OrElse(Expression.AndAlso(Expression.Equal(maxPrice, zero), Expression.LessThanOrEqual(minPrice, value)), Expression.LessThanOrEqual(maxPrice, value));
                            }
                        }


                        // Product Subgroup, Product Keywords, or Featured Products
                        else if (query.QueryType == QueryType.ProductSubgroup || query.QueryType == QueryType.ProductKeywords || query.QueryType == QueryType.FeaturedProducts)
                        {
                            PropertyInfo         productProperty = typeof(Product).GetProperty("Id");
                            MemberExpression     productId       = Expression.Property(product, productProperty);
                            ConstantExpression   values          = Expression.Constant(query.IntValues);
                            MethodInfo           method          = query.IntValues.GetType().GetMethod("Contains");
                            MethodCallExpression call            = Expression.Call(values, method, productId);
                            right = Expression.Equal(call, Expression.Constant(true));
                        }


                        // Product Creation Date
                        else if (query.QueryType == QueryType.ProductCreationDate)
                        {
                            PropertyInfo       dateProperty = typeof(Product).GetProperty("Date");
                            MemberExpression   date         = Expression.Property(product, dateProperty);
                            ConstantExpression value        = Expression.Constant(query.DateValue);

                            if (query.ComparisonOperator == ComparisonOperatorType.Equal)
                            {
                                right = Expression.Equal(date, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.NotEqual)
                            {
                                right = Expression.NotEqual(date, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.GreaterThan)
                            {
                                right = Expression.GreaterThan(date, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.GreaterThanOrEqual)
                            {
                                right = Expression.GreaterThanOrEqual(date, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.LessThan)
                            {
                                right = Expression.LessThan(date, value);
                            }
                            if (query.ComparisonOperator == ComparisonOperatorType.LessThanOrEqual)
                            {
                                right = Expression.LessThanOrEqual(date, value);
                            }
                        }


                        // Subquery
                        else if (query.QueryType == QueryType.SubQuery)
                        {
                            right = GetQueries(query.SubQueries);
                        }



                        if (left.Count == 0)
                        {
                            left.Add(right);
                        }


                        if (left[^ 1] != right)
Пример #20
0
 protected virtual Expression VisitConstant(ConstantExpression node)
 {
     return(null);
 }
Пример #21
0
 protected override Expression VisitConstant(ConstantExpression node)
 {
     this.count = (int)node.Value;
     return(base.VisitConstant(node));
 }
Пример #22
0
        static void DisplayTree(int indent, string message, Expression expression)
        {
            string output = $"{string.Empty.PadLeft(indent, '>')}{message}" + $"!NodeType:{expression.NodeType};Expr:{expression}";

            indent++;
            switch (expression.NodeType)
            {
            case ExpressionType.Add:
                break;

            case ExpressionType.AddAssign:
                break;

            case ExpressionType.AddAssignChecked:
                break;

            case ExpressionType.AddChecked:
                break;

            case ExpressionType.And:
                break;

            case ExpressionType.AndAlso:
                break;

            case ExpressionType.AndAssign:
                break;

            case ExpressionType.ArrayIndex:
                break;

            case ExpressionType.ArrayLength:
                break;

            case ExpressionType.Assign:
                break;

            case ExpressionType.Block:
                break;

            case ExpressionType.Call:
                break;

            case ExpressionType.Coalesce:
                break;

            case ExpressionType.Conditional:
                break;

            case ExpressionType.Constant:
                ConstantExpression constExpr = (ConstantExpression)expression;
                Console.WriteLine($"{output} Const Value{constExpr.Value}");
                break;

            case ExpressionType.Convert:
                break;

            case ExpressionType.ConvertChecked:
                break;

            case ExpressionType.DebugInfo:
                break;

            case ExpressionType.Decrement:
                break;

            case ExpressionType.Default:
                break;

            case ExpressionType.Divide:
                break;

            case ExpressionType.DivideAssign:
                break;

            case ExpressionType.Dynamic:
                break;

            case ExpressionType.Equal:
                break;

            case ExpressionType.ExclusiveOr:
                break;

            case ExpressionType.ExclusiveOrAssign:
                break;

            case ExpressionType.Extension:
                break;

            case ExpressionType.Goto:
                break;

            case ExpressionType.GreaterThan:
                BinaryExpression binExpr = (BinaryExpression)expression;
                if (binExpr.Method != null)
                {
                    Console.WriteLine($"{output} Method:{binExpr.Method.Name}");
                }
                else
                {
                    Console.WriteLine(output);
                }
                DisplayTree(indent, "Left", binExpr.Left);
                DisplayTree(indent, "Right", binExpr.Right);
                break;

            case ExpressionType.GreaterThanOrEqual:
                break;

            case ExpressionType.Increment:
                break;

            case ExpressionType.Index:
                break;

            case ExpressionType.Invoke:
                break;

            case ExpressionType.IsFalse:
                break;

            case ExpressionType.IsTrue:
                break;

            case ExpressionType.Label:
                break;

            case ExpressionType.Lambda:
                Console.WriteLine(output);
                LambdaExpression lambdaExpression = (LambdaExpression)expression;
                foreach (var parameter in lambdaExpression.Parameters)
                {
                    DisplayTree(indent, "Parameter", parameter);
                }
                DisplayTree(indent, "Body", lambdaExpression.Body);
                break;

            case ExpressionType.LeftShift:
                break;

            case ExpressionType.LeftShiftAssign:
                break;

            case ExpressionType.LessThan:
                break;

            case ExpressionType.LessThanOrEqual:
                break;

            case ExpressionType.ListInit:
                break;

            case ExpressionType.Loop:
                break;

            case ExpressionType.MemberAccess:
                MemberExpression memberExpr = (MemberExpression)expression;
                Console.WriteLine($"{output}Member Name{memberExpr.Member.Name}Type{memberExpr.Expression}");
                break;

            case ExpressionType.MemberInit:
                break;

            case ExpressionType.Modulo:
                break;

            case ExpressionType.ModuloAssign:
                break;

            case ExpressionType.Multiply:
                break;

            case ExpressionType.MultiplyAssign:
                break;

            case ExpressionType.MultiplyAssignChecked:
                break;

            case ExpressionType.MultiplyChecked:
                break;

            case ExpressionType.Negate:
                break;

            case ExpressionType.NegateChecked:
                break;

            case ExpressionType.New:
                break;

            case ExpressionType.NewArrayBounds:
                break;

            case ExpressionType.NewArrayInit:
                break;

            case ExpressionType.Not:
                break;

            case ExpressionType.NotEqual:
                break;

            case ExpressionType.OnesComplement:
                break;

            case ExpressionType.Or:
                break;

            case ExpressionType.OrAssign:
                break;

            case ExpressionType.OrElse:
                break;

            case ExpressionType.Parameter:
                ParameterExpression paramExpr = (ParameterExpression)expression;
                Console.WriteLine($"{output} Param Type:{paramExpr.Type.Name}");
                break;

            case ExpressionType.PostDecrementAssign:
                break;

            case ExpressionType.PostIncrementAssign:
                break;

            case ExpressionType.Power:
                break;

            case ExpressionType.PowerAssign:
                break;

            case ExpressionType.PreDecrementAssign:
                break;

            case ExpressionType.PreIncrementAssign:
                break;

            case ExpressionType.Quote:
                break;

            case ExpressionType.RightShift:
                break;

            case ExpressionType.RightShiftAssign:
                break;

            case ExpressionType.RuntimeVariables:
                break;

            case ExpressionType.Subtract:
                break;

            case ExpressionType.SubtractAssign:
                break;

            case ExpressionType.SubtractAssignChecked:
                break;

            case ExpressionType.SubtractChecked:
                break;

            case ExpressionType.Switch:
                break;

            case ExpressionType.Throw:
                break;

            case ExpressionType.Try:
                break;

            case ExpressionType.TypeAs:
                break;

            case ExpressionType.TypeEqual:
                break;

            case ExpressionType.TypeIs:
                break;

            case ExpressionType.UnaryPlus:
                break;

            case ExpressionType.Unbox:
                break;

            default:
                Console.WriteLine();
                Console.WriteLine($"{expression.NodeType}{expression.Type.Name}");
                break;
            }
        }
Пример #23
0
        /// <summary>
        /// 验证重复数据
        /// </summary>
        protected void ValidateDuplicateData()
        {
            //获取设定的重复字段信息
            var checkCondition = SetDuplicatedCheck();

            if (checkCondition != null && checkCondition.Groups.Count > 0)
            {
                //生成基础Query
                var baseExp              = DC.Set <TModel>().AsQueryable();
                var modelType            = typeof(TModel);
                ParameterExpression para = Expression.Parameter(modelType, "tm");
                //循环所有重复字段组
                foreach (var group in checkCondition.Groups)
                {
                    List <Expression> conditions = new List <Expression>();
                    //生成一个表达式,类似于 x=>x.Id != id,这是为了当修改数据时验证重复性的时候,排除当前正在修改的数据
                    MemberExpression   idLeft     = Expression.Property(para, "Id");
                    ConstantExpression idRight    = Expression.Constant(Entity.ID);
                    BinaryExpression   idNotEqual = Expression.NotEqual(idLeft, idRight);
                    conditions.Add(idNotEqual);
                    List <PropertyInfo> props = new List <PropertyInfo>();
                    //在每个组中循环所有字段
                    foreach (var field in group.Fields)
                    {
                        Expression exp = field.GetExpression(Entity, para);
                        if (exp != null)
                        {
                            conditions.Add(exp);
                        }
                        //将字段名保存,为后面生成错误信息作准备
                        props.AddRange(field.GetProperties());
                    }
                    int count = 0;
                    if (conditions.Count > 1)
                    {
                        //循环添加条件并生成Where语句
                        Expression conExp = conditions[0];
                        for (int i = 1; i < conditions.Count; i++)
                        {
                            conExp = Expression.And(conExp, conditions[i]);
                        }

                        MethodCallExpression whereCallExpression = Expression.Call(
                            typeof(Queryable),
                            "Where",
                            new Type[] { modelType },
                            baseExp.Expression,
                            Expression.Lambda <Func <TModel, bool> >(conExp, new ParameterExpression[] { para }));
                        var result = baseExp.Provider.CreateQuery(whereCallExpression);

                        foreach (var res in result)
                        {
                            count++;
                        }
                    }
                    if (count > 0)
                    {
                        //循环拼接所有字段名
                        string AllName = "";
                        foreach (var prop in props)
                        {
                            string name = PropertyHelper.GetPropertyDisplayName(prop);
                            AllName += name + ",";
                        }
                        if (AllName.EndsWith(","))
                        {
                            AllName = AllName.Remove(AllName.Length - 1);
                        }
                        //如果只有一个字段重复,则拼接形成 xxx字段重复 这种提示
                        if (props.Count == 1)
                        {
                            MSD.AddModelError(GetValidationFieldName(props[0])[0], AllName + "字段重复");
                        }
                        //如果多个字段重复,则拼接形成 xx,yy,zz组合字段重复 这种提示
                        else if (props.Count > 1)
                        {
                            MSD.AddModelError(GetValidationFieldName(props.First())[0], AllName + "字段组合重复");
                        }
                    }
                }
            }
        }
Пример #24
0
 protected override object VisitConstant(ConstantExpression exp)
 {
     return(exp.Value);
 }
Пример #25
0
 protected virtual Expression VisitConstant(ConstantExpression c)
 {
     return(c);
 }
Пример #26
0
 static object GetValue(ConstantExpression methodCall)
 {
     return(methodCall.Value);
 }
Пример #27
0
 /// <summary>
 /// CompareConstant
 /// </summary>
 /// <param name="x"></param>
 /// <param name="y"></param>
 /// <returns></returns>
 protected virtual int CompareConstant(ConstantExpression x, ConstantExpression y)
 {
     return(Comparer.Default.Compare(x.Value, y.Value));
 }
Пример #28
0
 protected override Expression VisitConstant(ConstantExpression node)
 {
     return(base.VisitConstant(node));
 }
 protected virtual Expression VisitConstantExpression(ConstantExpression expression)
 {
     ArgumentUtility.CheckNotNull("expression", expression);
     return(expression);
 }
 /// <summary>
 ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
 ///     directly from your code. This API may change or be removed in future releases.
 /// </summary>
 public abstract bool TryPrintConstant(
     [NotNull] ConstantExpression constantExpression,
     [NotNull] IndentedStringBuilder stringBuilder,
     bool removeFormatting);
Пример #31
0
        private static string Resolve(Expression expression)
        {
            if (expression is LambdaExpression)
            {
                LambdaExpression lambda = expression as LambdaExpression;
                expression = lambda.Body;
                return(Resolve(expression));
            }
            if (expression is BinaryExpression)
            {
                BinaryExpression binary = expression as BinaryExpression;
                if (binary.Left is MemberExpression && binary.Right is ConstantExpression)//解析x=>x.Name=="123" x.Age==123这类
                {
                    return(ResolveFunc(binary.Left, binary.Right, binary.NodeType));
                }
                if (binary.Left is MethodCallExpression && binary.Right is ConstantExpression)//解析x=>x.Name.Contains("xxx")==false这类的
                {
                    object value = (binary.Right as ConstantExpression).Value;
                    return(ResolveLinqToObject(binary.Left, value, binary.NodeType));
                }
                if ((binary.Left is MemberExpression && binary.Right is MemberExpression) ||
                    (binary.Left is MemberExpression && binary.Right is UnaryExpression))   //解析x=>x.Date==DateTime.Now这种
                {
                    LambdaExpression   lambda = Expression.Lambda(binary.Right);
                    Delegate           fn     = lambda.Compile();
                    ConstantExpression value  = Expression.Constant(fn.DynamicInvoke(null), binary.Right.Type);
                    return(ResolveFunc(binary.Left, value, binary.NodeType));
                }
            }
            if (expression is UnaryExpression)
            {
                UnaryExpression unary = expression as UnaryExpression;
                if (unary.Operand is MethodCallExpression)//解析!x=>x.Name.Contains("xxx")或!array.Contains(x.Name)这类
                {
                    return(ResolveLinqToObject(unary.Operand, false));
                }
                if (unary.Operand is MemberExpression && unary.NodeType == ExpressionType.Not)//解析x=>!x.isDeletion这样的
                {
                    ConstantExpression constant = Expression.Constant(false);
                    return(ResolveFunc(unary.Operand, constant, ExpressionType.Equal));
                }
            }
            if (expression is MemberExpression && expression.NodeType == ExpressionType.MemberAccess)//解析x=>x.isDeletion这样的
            {
                MemberExpression   member   = expression as MemberExpression;
                ConstantExpression constant = Expression.Constant(true);
                return(ResolveFunc(member, constant, ExpressionType.Equal));
            }
            if (expression is MethodCallExpression)//x=>x.Name.Contains("xxx")或array.Contains(x.Name)这类
            {
                MethodCallExpression methodcall = expression as MethodCallExpression;
                return(ResolveLinqToObject(methodcall, true));
            }
            var body = expression as BinaryExpression;

            //已经修改过代码body应该不会是null值了
            if (body == null)
            {
                return(string.Empty);
            }
            var    Operator = GetOperator(body.NodeType);
            var    Left     = Resolve(body.Left);
            var    Right    = Resolve(body.Right);
            string Result   = string.Format("({0} {1} {2})", Left, Operator, Right);

            return(Result);
        }
Пример #32
0
 //表达式路由计算
 public static string ExpressionRouter(Expression exp)
 {
     if (exp is MemberExpression)
     {
         MemberExpression me = ((MemberExpression)exp);
         return(me.Member.Name);
     }
     else if (exp is NewArrayExpression)
     {
         NewArrayExpression ae     = ((NewArrayExpression)exp);
         StringBuilder      tmpstr = new StringBuilder();
         foreach (Expression ex in ae.Expressions)
         {
             tmpstr.Append(ExpressionRouter(ex));
             tmpstr.Append(",");
         }
         return(tmpstr.ToString(0, tmpstr.Length - 1));
     }
     else if (exp is MethodCallExpression)
     {
         MethodCallExpression mce = (MethodCallExpression)exp;
         if (mce.Method.Name == "Like")
         {
             return(string.Format("({0} LIKE {1})", ExpressionRouter(mce.Arguments[0]), ExpressionRouter(mce.Arguments[1])));
         }
         else if (mce.Method.Name == "NotLike")
         {
             return(string.Format("({0} Not LIKE {1})", ExpressionRouter(mce.Arguments[0]), ExpressionRouter(mce.Arguments[1])));
         }
         else if (mce.Method.Name == "In")
         {
             return(string.Format("{0} IN ({1})", ExpressionRouter(mce.Arguments[0]), ExpressionRouter(mce.Arguments[1])));
         }
         else if (mce.Method.Name == "NotIn")
         {
             return(string.Format("{0} NOT IN ({1})", ExpressionRouter(mce.Arguments[0]), ExpressionRouter(mce.Arguments[1])));
         }
     }
     else if (exp is ConstantExpression)
     {
         ConstantExpression ce = ((ConstantExpression)exp);
         if (ce.Value == null)
         {
             return("null");
         }
         else if (ce.Value is ValueType)
         {
             return(ce.Value.ToString());
         }
         else if (ce.Value is string || ce.Value is DateTime || ce.Value is char)
         {
             return(string.Format("'{0}'", ce.Value.ToString()));
         }
     }
     else if (exp is UnaryExpression)
     {
         UnaryExpression ue = ((UnaryExpression)exp);
         return(ExpressionRouter(ue.Operand));
     }
     return(null);
 }
Пример #33
0
 protected virtual void VisitConstant(ConstantExpression node)
 {
     ConstantReference(node?.Value);
 }
Пример #34
0
 /// <summary>
 ///   Generates the node structure required to generate a default
 ///   initialization.
 /// </summary>
 /// <param name = "p">
 ///   Tools.Parser instance to use when instantiating nodes.
 /// </param>
 /// <param name = "constantType">String describing the datatype.</param>
 /// <returns>
 ///   A SYMBOL node conaining the appropriate structure for intializing a
 ///   constantType.
 /// </returns>
 private SYMBOL GetZeroConstant(Parser p, string constantType)
 {
     switch (constantType)
     {
         case "integer":
             return new Constant(p, constantType, "0");
         case "float":
             return new Constant(p, constantType, "0.0");
         case "string":
         case "key":
             return new Constant(p, constantType, "");
         case "list":
             ArgumentList al = new ArgumentList(p);
             return new ListConstant(p, al);
         case "vector":
             Constant vca = new Constant(p, "float", "0.0");
             Constant vcb = new Constant(p, "float", "0.0");
             Constant vcc = new Constant(p, "float", "0.0");
             ConstantExpression vcea = new ConstantExpression(p, vca);
             ConstantExpression vceb = new ConstantExpression(p, vcb);
             ConstantExpression vcec = new ConstantExpression(p, vcc);
             return new VectorConstant(p, vcea, vceb, vcec);
         case "rotation":
             Constant rca = new Constant(p, "float", "0.0");
             Constant rcb = new Constant(p, "float", "0.0");
             Constant rcc = new Constant(p, "float", "0.0");
             Constant rcd = new Constant(p, "float", "0.0");
             ConstantExpression rcea = new ConstantExpression(p, rca);
             ConstantExpression rceb = new ConstantExpression(p, rcb);
             ConstantExpression rcec = new ConstantExpression(p, rcc);
             ConstantExpression rced = new ConstantExpression(p, rcd);
             return new RotationConstant(p, rcea, rceb, rcec, rced);
         default:
             return null; // this will probably break stuff
     }
 }
 /// <summary>
 /// Creates a <see cref="ConstantExpression"/> that has the <see cref="P:ConstantExpression.Value"/> property set to the specified value. .
 /// </summary>
 /// <param name="value">An <see cref="System.Object"/> to set the <see cref="P:ConstantExpression.Value"/> property equal to.</param>
 /// <returns>
 /// A <see cref="ConstantExpression"/> that has the <see cref="P:Expression.NodeType"/> property equal to
 /// <see cref="F:ExpressionType.Constant"/> and the <see cref="P:Expression.Value"/> property set to the specified value.
 /// </returns>
 public static ConstantExpression Constant(object value)
 {
     return(ConstantExpression.Make(value, value == null ? typeof(object) : value.GetType()));
 }
Пример #36
0
 static object GetRuntimeConstant(ConstantExpression ce)
 {
   if (ce.Value is Microsoft.Scripting.Generation.CompilerConstant)
   {
     var cc = (Microsoft.Scripting.Generation.CompilerConstant)ce.Value;
     return cc.Create();
   }
   return ce.Value;
 }
Пример #37
0
 public MyConstantExpression(ConstantExpression expression)
 {
     _expression = expression;
 }
Пример #38
0
 // ConstantExpression
 protected internal virtual bool Walk(ConstantExpression node) { return true; }
 protected override Expression VisitConstant(ConstantExpression constantExpression)
 => constantExpression.Type.GetTypeInfo().IsGenericType &&
 constantExpression.Type.GetGenericTypeDefinition() == typeof(EntityQueryable <>)
         ? VisitEntityQueryable(((IQueryable)constantExpression.Value).ElementType)
         : constantExpression;
Пример #40
0
        public void CanFindItems(object value, int blockSize)
        {
            ConstantExpression[] values = new ConstantExpression[blockSize];
            for (int i = 0; i != values.Length; ++i)
                values[i] = Expression.Constant(value);

            BlockExpression block = Expression.Block(SingleParameter, values);

            IList<Expression> expressions = block.Expressions;

            for (int i = 0; i != values.Length; ++i)
                Assert.Equal(i, expressions.IndexOf(values[i]));
        }
Пример #41
0
        /// <summary>
        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
        ///     any release. You should only use it directly in your code with extreme caution and knowing that
        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
        /// </summary>
        protected override Expression VisitConstant(ConstantExpression constantExpression)
        {
            Check.NotNull(constantExpression, nameof(constantExpression));

            return(new SqlConstantExpression(constantExpression, null));
        }
Пример #42
0
 // ConstantExpression
 public override bool Walk(ConstantExpression node) { return false; }
Пример #43
0
 /// <summary>
 /// Visits a ConstantExpression.
 /// </summary>
 /// <param name="node">The ConstantExpression.</param>
 /// <returns>The result of visiting the Expression.</returns>
 protected virtual T VisitConstant(ConstantExpression node)
 {
     return(default(T));
 }
Пример #44
0
 // ConstantExpression
 public virtual bool Walk(ConstantExpression node) { return true; }
            protected override Expression VisitConstant(ConstantExpression node)
            {
                _rootNode = new TreeNode(node.ToString());

                return(node);
            }
Пример #46
0
        private void EmitConstantExpression(Expression expr)
        {
            ConstantExpression node = (ConstantExpression)expr;

            EmitConstant(node.Value, node.Type);
        }
 public ConstantExpressionProxy(ConstantExpression node) {
     _node = node;
 }
Пример #48
0
 public override bool Walk(ConstantExpression node)
 {
     AddTagIfNecessary(_ast.GetLineEndFromPosition(node.StartIndex), node.EndIndex);
     return(base.Walk(node));
 }
Пример #49
0
 public override bool Walk(ConstantExpression node)
 {
     node.Parent = _currentScope;
     return base.Walk(node);
 }
Пример #50
0
 private static bool CompareConstant(ConstantExpression a, ConstantExpression b)
 => Equals(a.Value, b.Value);
Пример #51
0
 protected override Expression VisitConstant(ConstantExpression node)
 {
     return Expression.Constant(node.Value, node.Type); // clones
 }
 protected abstract T GetResultFromConstant(ConstantExpression node);
Пример #53
0
 protected internal virtual void PostWalk(ConstantExpression node) { }
 protected sealed override Expression VisitConstant(ConstantExpression node)
 {
     Result = resultVisitor.GetResultFromConstant(node);
     return(node);
 }
Пример #55
0
        public void ExpressionsEnumerable(object value, int blockSize)
        {
            ConstantExpression[] values = new ConstantExpression[blockSize];
            for (int i = 0; i != values.Length; ++i)
                values[i] = Expression.Constant(value);

            BlockExpression block = Expression.Block(SingleParameter, values);

            Assert.True(values.SequenceEqual(block.Expressions));
            int index = 0;
            foreach (Expression exp in ((IEnumerable)block.Expressions))
                Assert.Same(exp, values[index++]);
        }
Пример #56
0
 protected override Expression VisitConstant(ConstantExpression node)
 {
     _filter.Append(ConvertSqlLiteral(node.Value, node.Type));
     return(node);
 }
Пример #57
0
 public override void PostWalk(ConstantExpression node) { }
Пример #58
0
 internal virtual Expression VisitConstant(ConstantExpression c)
 {
     return(c);
 }
Пример #59
0
 public virtual void PostWalk(ConstantExpression node) { }
 protected override Expression VisitConstant(ConstantExpression node)
 {
     return(node.Value == _originalQueryable ? _replacementQueryable : node);
 }