解释器模式 c#

　　解释器模是一种按照规定语法进行解析的方案。

 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication1
{
    class Program
    {

        public abstract class Node
        {
            public abstract double Interpret();
        }

      public class ValueNode : Node
      {
          private double value;

          public ValueNode(double value)
          {
              this.value = value;
          }

          public override double Interpret()
          {
              return this.value;
          }
      }


        public abstract class SymbolNode : Node
        {
            protected Node left;
            protected Node right;


            public SymbolNode(Node left, Node right)
            {
                this.left = left;
                this.right = right;
            }

        }

        public class MulNode : SymbolNode
        {
            public MulNode(Node left, Node right) : base(left, right)
            {

            }

            public override double Interpret()
            {
                return left.Interpret()*right.Interpret();
            }
        }

        public class ModNode : SymbolNode
        {
            public ModNode(Node left, Node right) : base(left, right)
            {
            }

            public override double Interpret()
            {
                return ((int)left.Interpret())%((int)right.Interpret());
            }
        }

        public class DivNode:SymbolNode
        {
            public DivNode(Node left, Node right) : base(left, right)
            {
            }

            public override double Interpret()
            {
                return left.Interpret()/right.Interpret();
            }
        }

        public class Calculator
        {
            private string statement;
            private Node node;

            public void Build(string statement)
            {
                Node left = null;
                Node right = null;
                Stack<Node> stack = new Stack<Node>();

                string[] statementArr = statement.Split(new char[] {' '});

                for (int i = 0; i < statementArr.Length; i++)
                {
                    if (statementArr[i].Equals("*"))
                    {
                        left = (Node) stack.Pop();
                        double val = Convert.ToDouble(statementArr[++i]);
                        right = new ValueNode(val);
                        stack.Push(new MulNode(left, right));
                    }
                    else if (statementArr[i].Equals("/"))
                    {
                        left = (Node)stack.Pop();
                        double val = Convert.ToDouble(statementArr[++i]);
                        right = new ValueNode(val);
                        stack.Push(new DivNode(left, right));
                    }
                    else if (statementArr[i].Equals("%"))
                    {
                        left = (Node)stack.Pop();
                        double val = Convert.ToDouble(statementArr[++i]);
                        right = new ValueNode(val);
                        stack.Push(new ModNode(left, right));
                    }
                    else
                    {
                        stack.Push(new ValueNode(Convert.ToDouble(statementArr[i])));
                    }
                }

                this.node = (Node) stack.Pop();
            }

            public double Compute()
            {
                return node.Interpret();
            }
        }

        static void Main(string[] args)
        {
            string statement = "3.5 * 4.5 / 2.6";

            Calculator cal = new Calculator();
            cal.Build(statement);

            Console.WriteLine(statement + "=" + cal.Compute());
        }
    }
}