观察者模式

观察者模式：定义了对象之间一对多的依赖关系，这样当一个对象（subject）改变的时候，其它对象（observer）会收到通知并自动更新。

在以下程序中，King既作为subject也作为observer。

OO原则：为对象之间的松耦合而努力。

 

策略模式，上篇文章中定义的一个抽象类，这里增加一个King类，继承自抽象类，实现了subject的功能，拥有一个对象引用的列表，对外提供增删对象的功能。

    abstract class Character
    {
        protected AttactBehavior At;//接口变量
        private string name;
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                this.name = value;
            }
        }
        public void fight()
        {
            if (At != null)
            {
                At.attact();
            }
        }
        public void setfightmethod(AttactBehavior At)
        {
            this.At = At;
        }
    }
    internal class Soldier : Character
    {
        public Soldier()
        {
            this.Name = "Solder";
        }
    }
    internal class King : Character
    {
        public King()
        {
            this.Name = "King";
        }
        ArrayList al = new ArrayList();
        public void Registercharacter(Character addcharacter)
        {
            if (!al.Contains(addcharacter))
            {
                al.Add(addcharacter);
            }
        }
        public void Removecharacter(Character removecharacter)
        {
            if (al.Contains(removecharacter))
            {
                al.Remove(removecharacter);
            }
        }
        public void Notifycharacter()
        {
            foreach (Character ch in al)
            {
                ch.fight();
            }
        }
    }

 

 

策略模式，上篇文章中定义的一个算法族：

 

 

    interface AttactBehavior
    {
        void attact();
    }
    internal class AttactWithKnife : AttactBehavior
    {
        public void attact()
        {
            Console.WriteLine("Attact with knife!");
        }
    }
    internal class AttactWithBox : AttactBehavior
    {
        public void attact()
        {
            Console.WriteLine("Attact with box!");
        }
    }

 

 

调用测试：

 

 

        static void Main(string[] args)
        {
            King K= new King();
            K.setfightmethod(new AttactWithKnife());
            Console.WriteLine(K.Name);
            Soldier a = new Soldier();
            a.setfightmethod(new AttactWithBox());
            Console.WriteLine(a.Name);
            Soldier b =new Soldier();
            b.setfightmethod(new AttactWithBox());
            Console.WriteLine(b.Name);
            Console.WriteLine("FirstTime");
            K.Registercharacter(a);
            K.Registercharacter(b);
            K.Registercharacter(K);
            K.Notifycharacter();
            Console.WriteLine("SecondTime");
            K.Removecharacter(a);
            K.Notifycharacter();
            Console.ReadLine();
        }

事实上，C#提供了事件机制，更加方便地实现观察者模式。