C# Expression.Evaluate方法代码示例

        public void ConstantFoldingDoesPreserveType()
        {
            DataTable dataTable = new DataTable();
            dataTable.Columns.Add("NonNullInt", typeof (int));
            dataTable.Columns.Add("NullInt", typeof (int));

            DataRow dataRow = dataTable.NewRow();
            dataRow["NonNullInt"] = 1;
            dataTable.Rows.Add(dataRow);
            
            DataColumnPropertyBinding[] dataRowProperties = DataRowPropertyProvider.GetProperties(dataTable);
            
            DataContext dataContext = new DataContext();
            dataContext.Constants.Add("DataRow", dataRow, dataRowProperties);

			Expression<object> exprWithNonNullInt = new Expression<object>();
            exprWithNonNullInt.DataContext = dataContext;
            exprWithNonNullInt.Text = "DataRow.NonNullInt";
            Assert.AreEqual(typeof(int), exprWithNonNullInt.Resolve());
            Assert.AreEqual(1, exprWithNonNullInt.Evaluate());

			Expression<object> exprWithNullInt = new Expression<object>();
            exprWithNullInt.DataContext = dataContext;
            exprWithNullInt.Text = "DataRow.NullInt";
            Assert.AreEqual(typeof(int), exprWithNullInt.Resolve());
            Assert.AreEqual(null, exprWithNullInt.Evaluate());
        }

		public void SimpleExpression()
		{
			Expression<string> expr = new Expression<string>("'Hello' + ' ' + 'World!'");
			string result = expr.Evaluate();

			Assert.AreEqual("Hello World!", result);
		}

		public void SimpleConversion()
		{
			Expression<double> expr = new Expression<double>("2 * 100");
			double result = expr.Evaluate();

			Assert.AreEqual(200.0d, result);
		}

		public void ConversionToLessSpecficWithBoxingToObject()
		{
			Expression<object> expr = new Expression<object>("2 + 2");
			object result = expr.Evaluate();

			Assert.AreEqual(4, result);
		}

        private static void Main(string[] args)
        {
            var expr = new Expression("233");

            Console.WriteLine(expr.Evaluate());

            Console.ReadLine();
        }

		public void OmittingOptionalAtWorksInExpression()
		{
			Expression<object> expression = new Expression<object>("MyParam1 + ' + ' + @MyParam2");
			expression.Parameters.Add("@MyParam1", typeof (string));
			expression.Parameters.Add("MyParam2", typeof (string));
			expression.Parameters["MyParam1"].Value = "MyParam1Value";
			expression.Parameters["@MyParam2"].Value = "MyParam2Value";
			object value = expression.Evaluate();
			Assert.AreEqual(value, "MyParam1Value + MyParam2Value");
		}

        public void Arithmetics(string formula)
        {
            var expression = new Expression(formula);
            var lambda = expression.ToLambda<object>();

            var m1 = Measure(() => expression.Evaluate());
            var m2 = Measure(() => lambda());

            PrintResult(formula, m1, m2);
        }

		public void ConversionToLessSpecificType2()
		{
			Derived derived = new Derived();

			Expression<Base> expr = new Expression<Base>("Test");
			expr.Parameters.Add("Test", typeof(Base), derived);
			Base result = expr.Evaluate();

			Assert.AreSame(derived, result);
		}

        public void ParameterAccess(string formula)
        {
            var expression = new Expression(formula);
            var lambda = expression.ToLambda<Context, int>();

            var context = new Context {Param1 = 4, Param2 = 9};
            expression.Parameters["Param1"] = 4;
            expression.Parameters["Param2"] = 9;

            var m1 = Measure(() => expression.Evaluate());
            var m2 = Measure(() => lambda(context));

            PrintResult(formula, m1, m2);
        }

		private static void ParameterScenario()
		{
			#region Parameter Scenario

			const int numberOfRuns = 10000;

			Console.WriteLine("Using constants and parameters in scenario where the value frequently changes.");
			Console.WriteLine("Executing scenario {0:N0} times.", numberOfRuns);

			int numberOfCompilations = 0;
			Stopwatch stopwatch;

			// Testing with constants

			Console.WriteLine("Constants");
			Expression<string> expressionUsingConstant = new Expression<string>();
			expressionUsingConstant.Text = "TO_STRING(MagicValue * 42 / 1000.0) + ' the result'";
			expressionUsingConstant.CompilationSucceeded += delegate { numberOfCompilations++; };

			numberOfCompilations = 0;
			stopwatch = Stopwatch.StartNew();
			for (int i = 0; i < numberOfRuns; i++)
			{
				expressionUsingConstant.DataContext.Constants.Add("MagicValue", i);
				expressionUsingConstant.Evaluate();
				expressionUsingConstant.DataContext.Constants.Remove("MagicValue");
			}
			Console.WriteLine("\tNeeded Time  : {0:N0} msecs", stopwatch.ElapsedMilliseconds);
			Console.WriteLine("\tCompilations : {0:N0}", numberOfCompilations);

			// Testing with parameters

			Console.WriteLine("Parameters");
			Expression<string> expressionUsingParameters = new Expression<string>();
			expressionUsingParameters.Parameters.Add("MagicValue", typeof(int));
			expressionUsingParameters.Text = "TO_STRING(MagicValue * 42 / 1000.0) + ' the result'";
			expressionUsingParameters.CompilationSucceeded += delegate { numberOfCompilations++; };

			numberOfCompilations = 0;
			stopwatch = Stopwatch.StartNew();
			for (int i = 0; i < numberOfRuns; i++)
			{
				expressionUsingParameters.Parameters["MagicValue"].Value = i;
				expressionUsingParameters.Evaluate();
			}
			Console.WriteLine("\tNeeded Time  : {0:N0} msecs", stopwatch.ElapsedMilliseconds);
			Console.WriteLine("\tCompilations : {0:N0}", numberOfCompilations);

			#endregion
		}

        public void CustomParametersShouldReturnNull()
        {
            var e = new Expression("x");

            e.EvaluateParameter += delegate(string name, ParameterArgs args)
            {
                Assert.IsFalse(args.HasResult);
                if (name == "x")
                    args.Result = null;
                Assert.IsTrue(args.HasResult);
            };

            Assert.AreEqual(null, e.Evaluate());
        }

        public void CustomFunctionShouldReturnNull()
        {
            var e = new Expression("SecretOperation(3, 6)");

            e.EvaluateFunction += delegate(string name, FunctionArgs args)
            {
                Assert.IsFalse(args.HasResult);
                if (name == "SecretOperation")
                    args.Result = null;
                Assert.IsTrue(args.HasResult);
            };

            Assert.AreEqual(null, e.Evaluate());
        }

        public void Add(Expression e)
        {
            // handle enumerables
            var ienum = e as IEnumerable;
            if (ienum != null)
            {
                foreach (var value in ienum)
                {
                    AddValue(value);
                }
                return;
            }

            // handle expressions
            AddValue(e.Evaluate());
        }

        public void DynamicParameterAccess(string formula)
        {
            var expression = new Expression(formula);
            var lambda = expression.ToLambda<Context, int>();

            var context = new Context { Param1 = 4, Param2 = 9 };
            expression.EvaluateParameter += (name, args) =>
            {
                if (name == "Param1") args.Result = context.Param1;
                if (name == "Param2") args.Result = context.Param2;
            };

            var m1 = Measure(() => expression.Evaluate());
            var m2 = Measure(() => lambda(context));

            PrintResult(formula, m1, m2);
        }

        private Expression EvaluateWhere(EvalStore store, Expression a, Expression b)
        {
            if (a.ExpressionType != ExpressionType.CONST) a = a.Evaluate(store);
            if (a.Value.DataType == ElementType.EMPTY) return ConstExpr.Empty;

            if (b.ExpressionType != ExpressionType.CONST) b = b.Evaluate(store);
            if (b.Value.DataType == ElementType.EMPTY) return ConstExpr.Empty;

            if (a.Value.DataType == ElementType.TABLE && b.Value.DataType == ElementType.TABLE) {
                Table r = (Table)a.Value;
                Table s = (Table)b.Value;
                r.IntersectWith(s);
                return new ConstExpr(r);
            }
            else {
                throw new Exception("Incompatible operands: " + a.Value.DataType + "," + b.Value.DataType);
            }
        }