IExpressionNode basic implementations.

VAR.ExpressionEvaluator.Tests/ExpressionBinaryNodeTests.cs

@@ -0,0 +1,64 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace VAR.ExpressionEvaluator.Tests
+{
+    [TestClass()]
+    public class ExpressionBinaryNodeTests
+    {
+        [TestMethod()]
+        public void ExpressionBinaryNode__Plus()
+        {
+            var expr = new ExpressionBinaryNode(
+                leftNode: new ExpressionNumberNode(10),
+                rightNode: new ExpressionNumberNode(20),
+                operation: (a, b) => (decimal)a + (decimal)b
+            );
+
+            var result = expr.Eval();
+
+            Assert.AreEqual(30m, result);
+        }
+
+        [TestMethod()]
+        public void ExpressionBinaryNode__Minus()
+        {
+            var expr = new ExpressionBinaryNode(
+                leftNode: new ExpressionNumberNode(10),
+                rightNode: new ExpressionNumberNode(20),
+                operation: (a, b) => (decimal)a - (decimal)b
+            );
+
+            var result = expr.Eval();
+
+            Assert.AreEqual(-10m, result);
+        }
+
+        [TestMethod()]
+        public void ExpressionBinaryNode__Multiply()
+        {
+            var expr = new ExpressionBinaryNode(
+                leftNode: new ExpressionNumberNode(10),
+                rightNode: new ExpressionNumberNode(20),
+                operation: (a, b) => (decimal)a * (decimal)b
+            );
+
+            var result = expr.Eval();
+
+            Assert.AreEqual(200m, result);
+        }
+
+        [TestMethod()]
+        public void ExpressionBinaryNode__Division()
+        {
+            var expr = new ExpressionBinaryNode(
+                leftNode: new ExpressionNumberNode(10),
+                rightNode: new ExpressionNumberNode(5),
+                operation: (a, b) => (decimal)a / (decimal)b
+            );
+
+            var result = expr.Eval();
+
+            Assert.AreEqual(2m, result);
+        }
+    }
+}

VAR.ExpressionEvaluator.Tests/ExpressionNumberNodeTests.cs

@@ -0,0 +1,29 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace VAR.ExpressionEvaluator.Tests
+{
+    [TestClass()]
+    public class ExpressionNumberNodeTests
+    {
+        [TestMethod()]
+        public void ExpressionNumberNode__One()
+        {
+            IExpressionNode node = new ExpressionNumberNode(1);
+            Assert.AreEqual(1m, node.Eval());
+        }
+
+        [TestMethod()]
+        public void ExpressionNumberNode__Two()
+        {
+            IExpressionNode node = new ExpressionNumberNode(2);
+            Assert.AreEqual(2m, node.Eval());
+        }
+
+        [TestMethod()]
+        public void ExpressionNumberNode__OneHundredDotFortyFive()
+        {
+            IExpressionNode node = new ExpressionNumberNode(100.45m);
+            Assert.AreEqual(100.45m, node.Eval());
+        }
+    }
+}

VAR.ExpressionEvaluator.Tests/ExpressionStringNodeTests.cs

@@ -0,0 +1,30 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace VAR.ExpressionEvaluator.Tests
+{
+    [TestClass()]
+    public class ExpressionStringNodeTests
+    {
+        [TestMethod()]
+        public void ExpressionNumberNode__Hello()
+        {
+            IExpressionNode node = new ExpressionStringNode("Hello");
+            Assert.AreEqual("Hello", node.Eval());
+        }
+
+        [TestMethod()]
+        public void ExpressionNumberNode__World()
+        {
+            IExpressionNode node = new ExpressionStringNode("World");
+            Assert.AreEqual("World", node.Eval());
+        }
+
+        [TestMethod()]
+        public void ExpressionNumberNode__Hello_World()
+        {
+            IExpressionNode node = new ExpressionStringNode("Hello World");
+            Assert.AreEqual("Hello World", node.Eval());
+        }
+
+    }
+}

VAR.ExpressionEvaluator.Tests/VAR.ExpressionEvaluator.Tests.csproj

@@ -51,6 +51,9 @@
     </Otherwise>
   </Choose>
   <ItemGroup>
+    <Compile Include="ExpressionBinaryNodeTests.cs" />
+    <Compile Include="ExpressionNumberNodeTests.cs" />
+    <Compile Include="ExpressionStringNodeTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TokenizerTests.cs" />
   </ItemGroup>

VAR.ExpressionEvaluator/ExpressionBinaryNode.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace VAR.ExpressionEvaluator
+{
+    public class ExpressionBinaryNode : IExpressionNode
+    {
+        private IExpressionNode _leftNode;
+        private IExpressionNode _rightNode;
+        private readonly Func<object, object, object> _operation;
+
+        public ExpressionBinaryNode(IExpressionNode leftNode, IExpressionNode rightNode, Func<object, object, object> operation)
+        {
+            _leftNode = leftNode;
+            _rightNode = rightNode;
+            _operation = operation;
+        }
+
+        public object Eval()
+        {
+            object leftValue = _leftNode.Eval();
+            object rightValue = _rightNode.Eval();
+
+            object result = _operation(leftValue, rightValue);
+            return result;
+        }
+    }
+}

VAR.ExpressionEvaluator/ExpressionNumberNode.cs

@@ -0,0 +1,17 @@
+namespace VAR.ExpressionEvaluator
+{
+    public class ExpressionNumberNode : IExpressionNode
+    {
+        private readonly decimal _number;
+
+        public ExpressionNumberNode(decimal number)
+        {
+            _number = number;
+        }
+
+        public object Eval()
+        {
+            return _number;
+        }
+    }
+}

VAR.ExpressionEvaluator/ExpressionStringNode.cs

@@ -0,0 +1,17 @@
+namespace VAR.ExpressionEvaluator
+{
+    public class ExpressionStringNode : IExpressionNode
+    {
+        private readonly string _string;
+
+        public ExpressionStringNode(string str)
+        {
+            _string = str;
+        }
+
+        public object Eval()
+        {
+            return _string;
+        }
+    }
+}

VAR.ExpressionEvaluator/IExpressionNode.cs

@@ -0,0 +1,7 @@
+namespace VAR.ExpressionEvaluator
+{
+    public interface IExpressionNode
+    {
+        object Eval();
+    }
+}

VAR.ExpressionEvaluator/VAR.ExpressionEvaluator.csproj

@@ -41,6 +41,10 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ExpressionBinaryNode.cs" />
+    <Compile Include="ExpressionStringNode.cs" />
+    <Compile Include="ExpressionNumberNode.cs" />
+    <Compile Include="IExpressionNode.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Tokenizer.cs" />
   </ItemGroup>