观察者模式之使用委托和事件实现

我们先看一下使用抽象类实现观察者模式的类图

代码如下：

发布者（主题）类

public class Subject
    {
        private readonly List<Observer> observers = new List<Observer>();
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        public void Notify()
        {
            foreach (var item in observers)
            {
                item.DoWork();
            }
        }
    }

订阅者类

public abstract class Observer
    {
        public abstract void DoWork();
    }

//订阅类A

public class ObserverA : Observer
    {
        public override void DoWork()
        {
            Console.WriteLine("Do something for A");
        }
}

订阅类B

public class ObserverB : Observer
    {
        public override void DoWork()
        {
            Console.WriteLine("Do something for B");
        }
    }

调用类

public static void Run()
        {
            Subject subject = new Subject();
            //
            Observer a = new ObserverA();
            Observer b = new ObserverB();
            //
            subject.Attach(a);
            subject.Attach(b);
            subject.Notify();
        }

这样我们就实现了观察者模式，Subject类依赖于Observer抽象，而不直接依赖于ObserverA B具体的实现，降低了Subject与Observer之间的耦合。然而我们发现Subject类仍然要依赖于Observer抽象，能否消除这两者的耦合呢？

答案当然是可以，那就是用委托和事件来实现

具体代码如下：

public class Subject
{
    //以下为委托实现方式
        public delegate void NotifyEventHandler();

        public event NotifyEventHandler NotifyEvent;

        public void Notify ()
        {
            if (NotifyEvent != null)
            {
                DoWork();
            }
        }
    }

Observer和实现类A 、B都不用变化

实现类中事件注册方法，代码如下

public class ObserverExecutor
    {
        public static void Run()
        {
            Subject subject = new Subject();
            subject.NotifyEvent += new ObserverA().DoWork;
            subject.NotifyEvent += new ObserverB().DoWork;
            //
            subject.NotifyMsg();
        }
    }

以上就是委托和事件实现的观察者模式，我们完全消除了Subject和Observer类之间的耦合，用事件和委托实现的是不是看起来更完美一点哈