• 拍摄路线：汉口江滩-长江大桥-武昌
• 拍摄时间：2010/07/25
• 拍摄主题：洪水来袭后的武汉
• 拍摄机器：Canon 400D / EF 24-70 2.8L
• 拍摄伙伴：骆大师…

更多精彩照片，点这里

Google 最近启用HTTPS 加密搜索服务。Google在官方博客介绍说，普通的HTTP浏览是不安全的，用户和服务器之间的通讯会被第三方监听和干扰，对于Google来说，你在Google搜索的词语会被第三方截获，如果第三方不希望你在Google搜索这个词语，还可以通过技术手段阻止用户的搜索行为。这也就是Google发布的beta版本的SSL加密搜索的原因，在HTTPS的Google搜索中，用户搜索的信息将无法被第三方获取，也不会出现数据泄漏的问题。目前HTTPS的Google搜索覆盖了Google网页搜索的部分产品，目前还不支持图片搜索和地图搜索，而其他搜素（资讯、博客、视频、动态等）都支持。

那关键问题是如何解决标题这个问题呢？不同的浏览器有不同的解决方案，请参见月光博客的这两篇博文：

Chrome 浏览器：Google支持HTTPS加密搜索

Firefox 和 IE8 浏览器：Google SSL搜索在FireFox和IE8中的解决方案

From the opening scene to the end, I was so moved by the love that Chris has for his son. It makes me to rethink about the meaning of happiness:

Happiness means a temperamental predominance of courage over timidity, of the appetite for adventure over the love of ease. So, No matter how bad the surrounding is, it won’t take our opportunity off to be happy, No matter how old we are, the process of the pursuit is endless.

When everything around goes against you, as it happens, the more cowardly you are, the more aggressive they will be. So, the first rule is brave. And it is just the prerequisite for you to overcome the difficulties.

Whether 40 or 14, there is in every human being’s heart the lure of wonder, the unfailing appetite of what’s next. At this moment, we should always make sure the balance between what we have and what we want to have. After a decision has been made, the only thing we can do, and should do, is “just go for it”.

The final scene shows Chris walking with his son down a street. His son is telling him a joke, when a man in a suit walks past. Chris looks back as the man continues on. The man in the suit is none other than the real Chris Gardner. Yes, another man is pursuing his happiness just as Chris does.

更多关于该影片的信息，点击这里

• 国家/地区： 美国
• 类型： 传记 /  剧情
• 片长：117 min
• 分级： USA:PG-13
• 对白语言： 英语
• 发行公司： Columbia TriStar Films de Argentina
• 官方网站： Gaumont Columbia Tristar

不要问我还记得哪些模式的哪些细节，他们无非是，1）面向接口编程；2）使用对象组合来解耦，努力避免继承；3）在易碎变化的地方进行封装。把面向的对象的精髓“封装、继承、多态”发挥到一定境界，就是模式了。

在学习设计模式之前，其实还有一点畏惧的情绪在里面。学习的过程中，发现，这样的模式，全然都是前辈们的经验。学习完之后，感觉自己还是内功不够，比如：数据结构。虽然，目前把这些模式都领略了一遍，但可以很清楚的意识到很多内在的精髓不一定内化到自己的脑袋里。今后在工程中可能还需要回过头来重新学习。这里把一个提纲式的笔记列一下：

意图

允许一个对象在其内部状态改变时改变它的行为。从而使对象看起来似乎修改了其行为。

结构图

话说，状态的改变也能用if-else 来完成逻辑演绎，但如果系统中增添了新的状态，则耦合的代码，就显得疲惫不堪了。如果状态很多，程序员自己也很难维护。这里的state 模式，将状态改变时影响的行为抽象到一个类里，用一个个具体的子类来表达不同的状态，从而很好的封装了变化点。

代码

using System;

namespace State
{
    class Program
    {
        static void Main(string[] args)
        {
            Document doc = new Document();
            Editable edit = new Editable();
            Insert ins = new Insert();
            edit.NextState = ins;
            doc.SetState(edit);
            doc.Handle();
            //查看轮换后的效果
            doc.Handle();
        }
    }

    abstract class StatedWithDocument {
        StatedWithDocument nextState;

        public StatedWithDocument NextState
        {
            get { return nextState; }
            set { nextState = value; }
        }

        public abstract void Handle();

    }
    class Document {
        StatedWithDocument state;

        public void SetState(StatedWithDocument state) {
            this.state = state;
        }
        public void Handle() {
            this.state.Handle();
            //也许需要轮换
            this.state = this.state.NextState;
        }
    }
    class Editable : StatedWithDocument {
        public override void Handle() {
            Console.WriteLine("Now,I'm Editable...");
        }
    }

    class Insert : StatedWithDocument {
        public override void Handle() {
            Console.WriteLine("Now,I'm Insertable...");
        }
    }
}

运行结果

如何实现对象状态的良好保存与恢复？但同时又不会因此而破坏对象本身的封装性。

意图

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以将该对象恢复到原先保存的状态。

结构图

其实结构图中Caretaker 不一定必须实现，不难发现的是，他是对“备忘录”中保存的状态的起到一种暂存的作用。下面是一段代码：

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace Memento
{
    class Program
    {
        static void Main(string[] args)
        {
            Person A = new Person("A");
            Person B = new Person("B");
            Person C = new Person("C");

            HRSystem hr = new HRSystem();
            hr.Add(A);
            hr.Add(B);
            Memento m = hr.CreatMemento();
            hr.Add(C);
            Console.WriteLine("After added C, we have :");
            hr.ShowInfo();
            Console.WriteLine("But, I've made a mistake...So:");
            hr.RecoverToMemento(m);
            hr.ShowInfo();
        }
    }
    [Serializable]
    class Person {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public Person(string name) {
            this.name = name;
        }
    }
    [Serializable]
    class HRSystem {
        List list = new List();

        public void ShowInfo() {
            Console.WriteLine("-----------------");
            foreach (Person p in list) {
                Console.WriteLine("{0} is available .",p.Name);
            }
            Console.WriteLine("-----------------");
        }

        public void Add(Person p) {
            if (list != null && !list.Contains(p)) {
                list.Add(p);
                Console.WriteLine("{0} has been added!", p.Name);
            }
        }

        public void Remove(Person p) {
            if (list != null && list.Contains(p)) {
                Console.WriteLine("{0} has been removed!",p.Name);
            }

        }

        public void SetHRList(HRSystem hr) {
            this.list = hr.list;
        }

        public Memento CreatMemento() {
            Console.WriteLine("Now ,Saving State above ↑...");
            return new Memento().SetMemento(this);
        }

        public void RecoverToMemento(Memento m) {
            Console.WriteLine("Recovering To Memento...");
            HRSystem hr = (HRSystem)m.GetMemento();
            this.SetHRList(hr);
        }

    }

    class Memento {
        MemoryStream ms = new MemoryStream();
        BinaryFormatter bf = new BinaryFormatter();
        public Memento SetMemento(object obj) {
            bf.Serialize(ms,obj);
            return this;
        }

        public object GetMemento() {
            ms.Seek(0,SeekOrigin.Begin);
            return bf.Deserialize(ms);
        }

    }

}

运行截图

意图

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

结构图

职责链模式在其内部实现了一个自我的链式结构，采用了和Decorator 模式一样的方法，不但继承了自己，还要包含自己。下面的代码，模拟了一个公司处理订单的业务逻辑，多少金额内，什么级别的人可以处理。

代码

using System;

namespace Chain_of_Responsibility
{
    class Program
    {
        static void Main(string[] args)
        {
            Purchase p = new Purchase(2012,9678.89,"Diamond For Women");
            President president = new President();
            VicePresident vicepresident = new VicePresident("Nobody-Care", president);
            Director director = new Director("Impp", vicepresident);

            director.ProcessRequest(p);
            p = new Purchase(2013, 159678.00, "Car For Women");
            director.ProcessRequest(p);
            p = new Purchase(2014, 459678.00, "House For Women");
            director.ProcessRequest(p);
        }
    }
    class Purchase {
        private int _number;

        public int Number
        {
            get { return _number; }
            set { _number = value; }
        }
        private double _amount;

        public double Amount
        {
            get { return _amount; }
            set { _amount = value; }
        }
        private string _purpose;

        public string Purpose
        {
            get { return _purpose; }
            set { _purpose = value; }
        }

        public Purchase(int number,double amount,string purpose) {
            this._amount = amount;
            this._number = number;
            this._purpose = purpose;
        }
    }

    abstract class Approver {
        protected Approver _successor;

        internal Approver Successor
        {
            get { return _successor; }
            set { _successor = value; }
        }
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public Approver(string name,Approver successor) {
            this._name = name;
            this._successor = successor;
        }

        public virtual void ProcessRequest(Purchase p) {
            if (this._successor != null) {
                this._successor.ProcessRequest(p);
            }
        }

    }

    class Director : Approver {
        public Director(string name, Approver successor) : base(name, successor) { }
        public Director() : base("Director", null) { }
        public override void ProcessRequest(Purchase p)  {
            if (p.Amount < 10000) {
                Console.WriteLine("{0} approved reqest #{1}",this.GetType().Name,p.Number);
            }
            else
                base.ProcessRequest(p);
        }
    }

    class VicePresident : Approver {
        public VicePresident(string name, Approver successor) : base(name, successor) { }
        public VicePresident() : base("Director", null) { }
        public override void ProcessRequest(Purchase p) {
            if(p.Amount<200000){
                Console.WriteLine("{0} approved reqest #{1}", this.GetType().Name, p.Number);
            }
            else
                base.ProcessRequest(p);
        }
    }

    class President : Approver {
        public President(string name, Approver successor) : base(name, successor) { }
        public President() : base("Director", null) { }
        public override void ProcessRequest(Purchase p)  {
            if (p.Amount < 500000) {
                Console.WriteLine("{0} approved reqest #{1}", this.GetType().Name, p.Number);
            }
            else
                Console.WriteLine("Request #{0} needs an excutive meeting!",p.Number);
        }
    }
}

运行结果

意图

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

结构图

从具体主题角色指向抽象观察者角色的合成关系，代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者，意味着主题对象不需要知道引用了哪些ConcreteObserver类型，而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的Update()方法。这种做法叫做”面向接口编程”。

实际上在C#中实现Observer模式没有这么辛苦，.NET中提供了Delegate与Event机制，我们可以利用这种机制简化Observer模式。下面我会用一段代码同时演示2种模式。

代码

using System;
using System.Collections.Generic;

namespace Observer
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("------------------------------");
            Console.WriteLine("使用观察者模式：");
            Email e = new Email();
            Mobole m = new Mobole();

            Microsoft ms = new Microsoft();
            ms.Add(e);
            ms.Add(m);
            ms.Price = 50;
            Console.WriteLine();
            Google g = new Google();
            g.Add(e); g.Add(m);
            g.Price = 220;
            Console.WriteLine("------------------------------");

            Console.WriteLine("使用Event 模式：");
            Google g2 = new Google();
            g2.priceChange += e.Update;
            g2.Price = 300;
            Microsoft m2 = new Microsoft();
            m2.priceChange += m.Update;
            m2.Price = 100;

        }
    }

    public interface IObserver {
        void Update(string symbol,decimal price);
    }

    public delegate void PriceChangeHandler(string symbol,decimal price);
    abstract class Stock {
        private string _symbol;
        private decimal _price;
        protected List list = new List();
        public event PriceChangeHandler priceChange;

        public decimal Price {
            get { return _price; }
            set {
                _price = value;
                this.Notify(this._symbol,this._price);
                this.OnChange(this._symbol, this._price);
            }
        }
        void OnChange(string symbol,decimal price) {
            if (priceChange != null)
                priceChange(symbol,price);
        }

        public Stock(string sysbol,decimal price) {
            this._price = price;
            this._symbol = sysbol;
        }

        public void Add(IObserver ob)  {
            list.Add(ob);
        }
        public void Remove(IObserver ob)  {
            list.Add(ob);
        }
        protected virtual void Notify(string symbol, decimal price)  {
            foreach (IObserver ob in list)
                ob.Update(symbol, price);
        }
    }

    class Microsoft:Stock {
        public Microsoft():base("Microsoft",120) { }
    }
    class Google : Stock {
        public Google() : base("Google", 200) { }
    }

    class Email:IObserver {
        public void Update(string symbol,decimal price) {
            Console.WriteLine("尊敬的客户，您使用Email 订阅了{0} 的股票，它的最新价格为 {1}!",symbol,price);
        }
    }
    class Mobole : IObserver {
        public void Update(string symbol, decimal price) {
            Console.WriteLine("尊敬的客户，您使用Mobile 订阅了{0} 的股票，它的最新价格为 {1}!", symbol, price);
        }
    }

}

运行结果

在软件构建过程中，经常会出现多个对象互相关联交互的情况，对象之间常常会维持一种复杂的引用关系，如果遇到一些需求的更改，这种直接的引用关系将面临不断的变化。在这种情况下，我们可使用一个“中介对象”来管理对象间的关联关系，避免相互交互的对象之间的紧耦合引用关系，从而更好地抵御变化。

意图

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式的相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

结构图

在这里，我们模拟一个聊天室的程序，用户既可以对特定的对象进行发送消息，也可以向所有人say hello。我们用一个mediator 对象进行管理他们之间的联系。值得指出的是，代码中，仍有值得抽象的接口。

代码：

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

namespace Mediator
{
    class Program
    {
        static void Main(string[] args)
        {
            ChatRoom cr = new ChatRoom();
            Participator p = new Participator("Shao mingbo",cr);
            Participator p2 = new Participator("YW",cr);
            Participator p3 = new Participator("ZZ",cr);
            Participator p4 = new Participator("Xiao Di",cr);
            //Say Hello to The One
            p.Send(p2,"Hello");
            Console.WriteLine("--------------");
            // Say Hi To All
            p4.Send("Hi");
        }
    }
    class Participator {
        private string _name;
        private ChatRoom cr;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public Participator(string name,ChatRoom cr) {
            this._name = name;
            this.cr = cr;
            cr.RegistParticipator(this);
        }
        public void Receive(string from,string msg) {
            if(cr!=null)
                Console.WriteLine("{0} 收到来自 {1}的一则消息： {2}", this.Name, from, msg);
            else
                Console.WriteLine("{0} 未曾在聊天室内注册！", this._name);
        }
        public void Send(Participator p,string msg) {
            if (cr != null) {
                cr.RegistParticipator(this);
                cr.Notify(this.Name,p, msg);
            }
            else
                Console.WriteLine("{0} 未曾在聊天室内注册！",this._name);

        }

        public void Send(string msg) {
            this.Send(null,msg);
        }
    }
    class ChatRoom {
        private Dictionary roomMate = new Dictionary();
        public void RegistParticipator(Participator p) {
            if (!roomMate.ContainsKey(p.Name))
                roomMate.Add(p.Name,p);
        }
        public void Notify(string from,Participator p, string msg) {
            if (p != null)
            {
                p.Receive(from, msg);
            }
            else {
                foreach (var receiver in roomMate) {
                    if (receiver.Key != from) {
                        Participator r = receiver.Value;
                        r.Receive(from,msg);
                    }
                }
            }
        }
    }

}

运行结果：

意图：
给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。

结构图：

这个模式让我纠结了几天。原因不在理解这个模式本身，而是老师在课堂举的一个解释器的例子（将汉语数字转换成阿拉伯数字。比如：九千一百二十万六千三百二十一 –>91206321 )这样的计算处理，不用设计模式，也能实现。但，使用了设计模式，可以在代码复用以及一些小型的语法处理问题得到很好的效果。当然最后还是实现了，但这充分说明，自己实现一个解释器，并不容易。

在写代码的过程中，我有尝试从最高位向低位来转换，但发现后期扩展就受到了这个方向的限制。所以，我得出了一个不完全的总结，就是在使用Interpretor 模式的过程中，应该先从最小的单位单元（个位）进行，然后依次递增。

代码：

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

namespace DesignPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            //初始化翻译数据...
            string[] numbers = { "九千一百二十万",
                                   "九千一百二十万六千三百二十一",
                                   "六千",
                                   "六千零一",
                                   "六千零一十",
                                   "六千一",
                                   "六千一百",
                                   "六千二百一十",
                                   "六千二百一",
                                   "六千二百零一",
                                   "六千零二十一",
                                   "六千三百二十一",
                                   "一百",
                                   "一百一",
                                   "一百一十",
                                   "一百零一",
                                   "一百一十一",
                                   "二十一",
                                   "二十",
                                   "八" };
            ArrayList contextList = new ArrayList();
            for (int i = 0; i < numbers.Length; i++)
            {
                contextList.Add(new Context(numbers[i]));
            }
            //初始化编译器...
            OneExpression one = new OneExpression();
            TenExpression ten = new TenExpression();
            HundredExpression hun = new HundredExpression();
            ThousandExpression thou = new ThousandExpression();
            TenThousandExpression tenThou = new TenThousandExpression();

            ArrayList list = new ArrayList();
            list.Add(one);
            list.Add(ten);
            list.Add(hun);
            list.Add(thou);
            list.Add(tenThou);

            //开始翻译工作啦...
            foreach (Context c in contextList)
            {
                Console.Write("Input: {0}\t", c.Input);
                foreach (Expression ex in list)
                    ex.Interprete(c);
                Console.WriteLine("Output: {0}", c.Output);

            }

        }
    }
    class Context {
        private string _input;

        public string Input
        {
            get { return _input; }
            set { _input = value; }
        }
        private long _output;

        public long Output
        {
            get { return _output; }
            set { _output = value; }
        }

        public Context(string input) {
            this._input = input;
        }
    }

    abstract class Expression
    {
        protected Dictionary charDic = new Dictionary();
        protected Stack mutiplier = new Stack();
        protected int _data;
        public Expression()
        {
            charDic.Add("一", 1);
            charDic.Add("二", 2); charDic.Add("两", 2);
            charDic.Add("三", 3); charDic.Add("四", 4);
            charDic.Add("五", 5); charDic.Add("六", 6);
            charDic.Add("七", 7); charDic.Add("八", 8);
            charDic.Add("九", 9);
        }
        public abstract void Interprete(Context context);
    }

    class OneExpression : Expression
    {
        public override void Interprete(Context context)
        {
            //throw new NotImplementedException();
            if (context.Input.Length <= 0) return;
            if (context.Input.Length == 1)
            {
                if (charDic.ContainsKey(context.Input))
                {
                    this._data = charDic[context.Input];
                    context.Output += this._data;
                    context.Input = String.Empty;
                    return;
                }
            }
            string lastWord = context.Input.Substring(context.Input.Length - 1);
            string preWord = context.Input.Substring(0, context.Input.Length - 1);
            if (context.Input.Length == 2)
            {
                if (charDic.ContainsKey(lastWord))
                {
                    this._data = charDic[lastWord];
                    context.Output += this._data;
                    context.Input = context.Input.Substring(0, context.Input.Length - 1);
                }
            }
            if (context.Input.Length > 2)
            {
                if (charDic.ContainsKey(lastWord))
                {
                    if (preWord.EndsWith("十") || preWord.EndsWith("零"))
                    {
                        this._data = charDic[lastWord];
                        context.Output += this._data;
                        context.Input = context.Input.Substring(0, context.Input.Length - 2);
                    }
                }
            }
        }
    }
    class TenExpression : Expression
    {
        public override void Interprete(Context context)
        {
            if (context.Input.Length <= 0) return;
            if (context.Input.Length == 1)
            {
                if (this.charDic.ContainsKey(context.Input))
                {
                    context.Output += charDic[context.Input] * 10;
                }
                if (context.Input.Equals("十"))
                {
                    context.Output += 10;
                }
                context.Input = String.Empty;
                return;
            }
            string lastWord = context.Input.Substring(context.Input.Length - 1);
            string preWord = context.Input.Substring(0, context.Input.Length - 1);
            if (context.Input.Length == 2)
            {
                if (lastWord.Equals("十"))
                {
                    if (this.charDic.ContainsKey(preWord))
                    {
                        context.Output += this.charDic[preWord] * 10;
                        context.Input = String.Empty;
                    }
                }
            }

            if (context.Input.Length > 2)
            {
                if (lastWord.Equals("十"))
                {
                    lastWord = preWord.Substring(preWord.Length - 1);
                    preWord = preWord.Substring(0, preWord.Length - 1);
                }
                if (this.charDic.ContainsKey(lastWord))
                {
                    if (preWord.EndsWith("百") || preWord.EndsWith("零"))
                    {
                        this._data = this.charDic[lastWord];
                        context.Output += this._data * 10;
                        context.Input = preWord.Substring(0, preWord.Length - 1);
                    }
                }
            }
        }
    }
    class HundredExpression : Expression
    {
        public override void Interprete(Context context)
        {
            if (context.Input.Length == 0) return;
            if (context.Input.Length == 1)
            {
                if (this.charDic.ContainsKey(context.Input))
                {
                    this._data = this.charDic[context.Input];
                    context.Output += this._data * 100;
                }
                context.Input = String.Empty;
                return;
            }
            string lastWord = context.Input.Substring(context.Input.Length - 1);
            string preWord = context.Input.Substring(0, context.Input.Length - 1);
            if (context.Input.Length == 2)
            {
                if (lastWord.Equals("百"))
                {
                    if (this.charDic.ContainsKey(preWord))
                    {
                        context.Output += this.charDic[preWord] * 100;
                        context.Input = String.Empty;
                    }
                }
            }
            if (context.Input.Length > 2)
            {
                if (lastWord.Equals("百"))
                {
                    lastWord = preWord.Substring(preWord.Length - 1);
                    preWord = preWord.Substring(0, preWord.Length - 1);
                }
                if (this.charDic.ContainsKey(lastWord))
                {
                    if (preWord.EndsWith("千") || preWord.EndsWith("零"))
                    {
                        this._data = this.charDic[lastWord];
                        context.Output += this._data * 100;
                        context.Input = preWord.Substring(0, preWord.Length - 1);
                    }
                }
            }
        }
    }
    class ThousandExpression : Expression
    {
        public override void Interprete(Context context)
        {
            if (context.Input.Length <= 0) return;
            if (context.Input.Length == 1)
            {
                if (this.charDic.ContainsKey(context.Input))
                {
                    this._data = this.charDic[context.Input];
                    context.Output += this._data * 1000;
                }
                context.Input = String.Empty;
                return;
            }
            string lastWord = context.Input.Substring(context.Input.Length - 1);
            string preWord = context.Input.Substring(0, context.Input.Length - 1);
            if (context.Input.Length == 2)
            {
                if (lastWord.Equals("千"))
                {
                    if (this.charDic.ContainsKey(preWord))
                    {
                        context.Output += this.charDic[preWord] * 1000;
                        context.Input = String.Empty;
                    }
                }
            }
            if (context.Input.Length > 2)
            {
                if (lastWord.Equals("千"))
                {
                    lastWord = preWord.Substring(preWord.Length - 1);
                    preWord = preWord.Substring(0, preWord.Length - 1);
                }
                if (this.charDic.ContainsKey(lastWord))
                {
                    if (preWord.EndsWith("万") || preWord.EndsWith("零"))
                    {
                        this._data = this.charDic[lastWord];
                        context.Output += this._data * 1000;
                        context.Input = preWord.Substring(0, preWord.Length - 1);
                    }
                }
            }
        }
    }
    class TenThousandExpression : Expression
    {
        public override void Interprete(Context context)
        {
            if (context.Input.Length <= 0) return;
            if (context.Input.EndsWith("万"))
            {
                context.Input = context.Input.Substring(0, context.Input.Length - 1);
            }
            long temp = context.Output;
            context.Output = 0;
            OneExpression one = new OneExpression();
            TenExpression ten = new TenExpression();
            HundredExpression hun = new HundredExpression();
            ThousandExpression thou = new ThousandExpression();
            ArrayList list = new ArrayList();
            list.Add(one);
            list.Add(ten);
            list.Add(hun);
            list.Add(thou);
            foreach (Expression ex in list)
            {
                ex.Interprete(context);
            }
            context.Output *= 10000;
            context.Output += temp;

        }
    }
}

运行结果：

这里是测试程序，如果有bug，请联系我哟。点击下载：Interpretor 演示代码 (30)