C# Context.GetValue方法代码示例

        public void GetValueUsingParent()
        {
            Context parent = new Context();
            Context context = new Context(parent);

            parent.SetValue("one", 1);
            Assert.IsTrue(context.HasValue("one"));
            Assert.IsFalse(context.HasValue("two"));
            Assert.AreEqual(1, context.GetValue("one"));
            Assert.IsNull(context.GetValue("two"));
        }

        public void DefineSetAndGetAndRemoveVariable()
        {
            Context context = new Context();

            context.DefineVariable("x");

            context.SetValue("x", 123);
            Assert.AreEqual(123, context.GetValue("x"));

            context.RemoveValue("x");
            Assert.AreSame(Undefined.Instance, context.GetValue("x"));
        }

        public void MatchTuplesWithAVariable()
        {
            Tuple tuple = new Tuple(new object[] { 1, new Variable("X"), 3 });
            Tuple tuple2 = new Tuple(new object[] { 1, 2, 3 });
            Context context = new Context();
            Assert.IsTrue(tuple.Match(tuple2, context));
            Assert.AreEqual(2, context.GetValue("X"));

            Assert.IsTrue(tuple2.Match(tuple, context));

            Assert.AreEqual(2, context.GetValue("X"));
        }

        public void MatchVariableInFunctionalExpression()
        {
            var one = new IntegerExpression(1);
            var two = new IntegerExpression(2);
            var expr = new FunctionalExpression(new AddIntegersFunction(), new IExpression[] { new NameExpression("a"), new NameExpression("b") });
            var expr1 = new FunctionalExpression(new AddIntegersFunction(), new IExpression[] { one, two });

            Context<IExpression> ctx = new Context<IExpression>();

            Assert.IsTrue(expr.Match(expr1, ctx));

            Assert.AreSame(one, ctx.GetValue("a"));
            Assert.AreSame(two, ctx.GetValue("b"));
        }

 public void GetValueFromParent()
 {
     Context parent = new Context();
     Context context = new Context(parent);
     parent.SetValue("One", 1);
     Assert.AreEqual(1, context.GetValue("One"));
 }

        public void ForWithAddExpression()
        {
            var command = new SetVariableCommand("a", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("k"), new VariableExpression("a")));
            var forcommand = new ForCommand("k", new ConstantExpression(new int[] { 1, 2, 3, 4 }), command);

            Context context = new Context();

            var result = forcommand.Execute(context);

            Assert.IsNull(result);
            Assert.AreEqual("k", forcommand.VariableName);
            Assert.IsNotNull(forcommand.Expression);
            Assert.IsNotNull(forcommand.Command);
            Assert.AreEqual(4, context.GetValue("k"));
            Assert.AreEqual(10, context.GetValue("a"));
        }

        public void SetAndGetValue()
        {
            Context context = new Context();
            context.SetValue("a", "One");

            Assert.AreEqual("One", context.GetValue("a"));
        }

        public void CreateAndExecuteDefineFunctionCommand()
        {
            IEnumerable<ICommand> commands = new ICommand[] {
                new SetVariableCommand("a", new ConstantExpression(1)),
                new SetVariableCommand("b", new ConstantExpression(2))
            };

            CompositeCommand body = new CompositeCommand(commands);
            DefineFunctionCommand command = new DefineFunctionCommand("foo", null, body);

            Context context = new Context();
            Assert.IsNull(command.Execute(context));
            Assert.AreEqual("foo", command.Name);
            Assert.IsNull(command.ArgumentNames);
            Assert.AreEqual(body, command.Command);

            var result = context.GetValue("foo");

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(DefinedFunction));

            DefinedFunction dfunc = (DefinedFunction)result;

            Assert.AreEqual(2, dfunc.Call(context, null));
        }

        public void DefineVariable()
        {
            Context context = new Context();

            context.DefineVariable("x");

            Assert.AreEqual(Undefined.Instance, context.GetValue("x"));
        }

        public void SetAndGetValue()
        {
            Context context = new Context();

            context.SetValue("one", 1);

            Assert.AreEqual(1, context.GetValue("one"));
        }

        public void MatchAnonymousVariable()
        {
            Context context = new Context();

            Assert.IsTrue(MatchUtilities.MatchObjects(new Variable("_"), 1, context));

            Assert.IsNull(context.GetValue("_"));
        }

 public void DefineAndHasVariable()
 {
     Context context = new Context();
     Assert.IsFalse(context.HasVariable("a"));
     context.DefineVariable("a");
     Assert.IsTrue(context.HasVariable("a"));
     Assert.IsNull(context.GetValue("a"));
 }

        public void SetAndGetValue()
        {
            var ctx = new Context<object>();

            ctx.SetValue("foo", 42);

            Assert.AreEqual(42, ctx.GetValue("foo"));
        }

        public void MatchVariableInverse()
        {
            Context context = new Context();

            Assert.IsTrue(MatchUtilities.MatchObjects(1, new Variable("X"), context));

            Assert.AreEqual(1, context.GetValue("X"));
        }

 public void SetAndGetValueWithParent()
 {
     Context parent = new Context();
     Context context = new Context(parent);
     context.SetValue("One", 1);
     Assert.AreEqual(1, context.GetValue("One"));
     Assert.IsNull(parent.GetValue("One"));
 }