设计模式（2）——观察者模式

首先要说的是观察者模式是十分重要的，就它的响应机制而言，几乎任何软件都涉及该功能；其次要声明的是我对观察者模式的理解还不够深入，我仅仅能通过委托和接口实现观察者模式，还未尝试用C#内置特性（C#提供观察者模式的接口）来实现该模式；最后要阐明的是不管哪种实现方式，都值得学习和研究，毕竟这个模式太重要了（应该也是一个很基础的模式吧）

目前明确两种实现方式：1.通过C#的委托（委托是C#的语言特性）实现；2.通过接口（或者基类）实现（与Java代码基本一样）。

通过C#委托实现：

 public delegate void ObserverMethod();
    public class Subject//主题，发布者
    {
        public ObserverMethod observerMethod;
        public void AddObserverMethod(ObserverMethod om)
        {
            observerMethod += om;
        }
        public void RemoveObserverMethod(ObserverMethod om)
        {
            if(observerMethod != null)
            {
                observerMethod -= om;
            }
        }
        public void Notify()//通知所有订阅者
        {
            observerMethod();
        }
    }
    public class Observer//订阅者，观察者
    {
        public void method1()
        {
            Console.WriteLine("I get your news!");
        }
    }
    public class Program
    {
        public static void Main()
        {
            Subject subject = new Subject();
            Observer observer = new Observer();
            subject.AddObserverMethod(observer.method1);
            subject.Notify();
            Console.Read();
        }
    }

用C#的委托实现方便快捷，通俗易懂，如果用传统的接口实现也完全可以，如下：

    public interface Subject//发布者接口
   {
        void Register(Observer ob);
        void Remover(Observer ob);
        void Notify();
   }
    public interface Observer//订阅者接口
   {
        void Update();
   }
    public class Alarm : Subject//具体的发布者
    {
        public List<Observer> observers = new List<Observer>();
        public void Notify()
        {
            for (int i = 0; i < observers.Count; i++)
            {
                Observer observer = observers[i];
                observer.Update();
            }
        }

        public void Register(Observer ob)
        {
            observers.Add(ob);
        }

        public void Remover(Observer ob)
        {
            int i = observers.IndexOf(ob);
            observers.RemoveAt(i);
        }
    }
    public class Observer1 : Observer//具体的订阅者
    {
        public void Update()
        {
            Console.WriteLine("I get your news!");
        }
    }
    public class Program
    {
        public static void Main()
        {
            Alarm alarm = new Alarm();
            Observer1 observer1 = new Observer1();
            alarm.Register(observer1);//注册观察者
            alarm.Notify();
            Console.Read();
        }
    }

用接口来实现这个过程也是清晰明了的，当然，把接口换成基类来实现这个过程，是一样可以的。

上述两种方法都可以在程序中采用，都是有较好OO编程思想的，接下里看一个反面例子

    public class Observer1//观察者1
    {
        public void Update()
        {
            Console.WriteLine("Observer1 get update");
        }
    }
    public class Observer2//观察者2
    {
        public void Update()
        {
            Console.WriteLine("observer2 get update");
        }
    }
    public class Subject//发布者
    {
        public void Notify()
        {
            Observer1 observer1 = new Observer1();
            Observer2 observer2 = new Observer2();
            observer1.Update();
            observer2.Update();
        }
    }
    public class Program
    {
        public static void Main()
        {
            Subject subject = new Subject();
            subject.Notify();//通知
            Console.Read();
        }
    }

看似也没问题，但是当我们想动态改变哪些类给予通知(监听)或者取消通知，就不得不把发布者类拆开了重新写，这样是违背OOP编程原则的。

后续还会补充对观察者模式的研究。