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

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

 

代码如下：

发布者（主题）类    

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类之间的耦合，用事件和委托实现的是不是看起来更完美一点哈