interpreterrealworld.cs

使用C#程序将23个常用设计模式进行列表显示

using System;
using System.Windows.Forms;
using System.Collections;


//解释器模式(Interpreter pattern)
//意图
//    给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
//适用性
//    1.当有一个语言需要解释执行, 并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。
//      而当存在以下情况时该模式效果最好：
//      a.该文法简单 -- 对于复杂的文法, 文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。
//        它们无需构建抽象语法树即可解释表达式, 这样可以节省空间而且还可能节省时间。
//      b.效率不是一个关键问题 -- 最高效的解释器通常不是通过直接解释语法分析树实现的, 而是首先将它们转换成另一种形式。
//        例如，正则表达式通常被转换成状态机。但即使在这种情况下, 转换器仍可用解释器模式实现, 该模式仍是有用的。

namespace DesignPattern.InterpreterRealWorld
{
    class InterpreterRealWorld : AbstractPattern
    {
        public static void Run(TextBox tbInfo)
        {
            s_tbInfo = tbInfo;
            s_tbInfo.Text = "";

            string roman = "MCMXXVIII"; 
            Context context = new Context(roman); 
            
            // Build the 'parse tree' 
            ArrayList tree = new ArrayList(); 
            tree.Add(new ThousandExpression()); 
            tree.Add(new HundredExpression()); 
            tree.Add(new TenExpression()); 
            tree.Add(new OneExpression()); 
            
            // Interpret 
            foreach (Expression exp in tree) 
            {
                exp.Interpret(context); 
            }
            
            DesignPattern.FormMain.OutputInfo("{0} = {1}", roman, context.Output); 
            
            // Wait for user 
            //Console.Read();
        }
    }
    
    // "Context" 
    class Context 
    {
        private string input; 
        private int output;
        
        // Constructor 
        public Context(string input)
        { 
            this.input = input; 
        }
        
        // Properties 
        public string Input 
        {
            get
            {
                return input; 
            }
            set
            {
                input = value; 
            }
        }
        
        public int Output 
        { 
            get
            { 
                return output; 
            } 
            set
            {
                output = value; 
            } 
        }
    } 
    
    // "AbstractExpression" 
    abstract class Expression 
    {
        public void Interpret(Context context) 
        {
            if (context.Input.Length == 0) 
                return; 

            if (context.Input.StartsWith(Nine())) 
            {
                context.Output += (9 * Multiplier()); 
                context.Input = context.Input.Substring(2); 
            }
            else if (context.Input.StartsWith(Four())) 
            {
                context.Output += (4 * Multiplier()); 
                context.Input = context.Input.Substring(2); 
            } 
            else if (context.Input.StartsWith(Five())) 
            {
                context.Output += (5 * Multiplier()); 
                context.Input = context.Input.Substring(1); 
            }

            while (context.Input.StartsWith(One()))
            { 
                context.Output += (1 * Multiplier()); 
                context.Input = context.Input.Substring(1); 
            }
        } 
        
        public abstract string One(); 
        public abstract string Four(); 
        public abstract string Five(); 
        public abstract string Nine(); 
        public abstract int Multiplier();
    } 
    
    // Thousand checks for the Roman Numeral M 
    // "TerminalExpression" 
    class ThousandExpression : Expression 
    {
        public override string One() 
        {
            return "M"; 
        }
        public override string Four()
        {
            return " "; 
        }
        public override string Five()
        {
            return " "; 
        }
        public override string Nine()
        {
            return " "; 
        } 
        public override int Multiplier() 
        {
            return 1000; 
        }
    }
    
    // Hundred checks C, CD, D or CM 
    // "TerminalExpression" 
    class HundredExpression : Expression 
    {
        public override string One() 
        {
            return "C"; 
        }
        public override string Four()
        {
            return "CD"; 
        }
        public override string Five()
        {
            return "D"; 
        }
        public override string Nine()
        {
            return "CM"; 
        }
        public override int Multiplier() 
        {
            return 100; 
        }
    }
    
    // Ten checks for X, XL, L and XC 
    // "TerminalExpression" 
    class TenExpression : Expression
    {
        public override string One() 
        {
            return "X"; 
        }
        public override string Four()
        {
            return "XL"; 
        }
        public override string Five() 
        {
            return "L"; 
        }
        public override string Nine() 
        {
            return "XC"; 
        }
        public override int Multiplier() 
        {
            return 10; 
        }

    } 
    
    // One checks for I, II, III, IV, V, VI, VI, VII, VIII, IX 
    // "TerminalExpression" 
    class OneExpression : Expression 
    {
        public override string One() { return "I"; }
        public override string Four(){ return "IV";} 
        public override string Five(){ return "V"; } 
        public override string Nine(){ return "IX";}
        public override int Multiplier() { return 1; } 
    }

}