c#设计模式——观察者模式

一 概要

1.1 行为型模式

1. 特别关注对象之间的通信。描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。

1.2 定义

1. 指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

二 UML类图

三 例子

    public class Subject
    {
        private List<IObserver> observers = new List<IObserver>();

        public void Add(IObserver observer)
        {
            observers.Add(observer);
        }

        public void Remove(IObserver observer)
        {
            observers.Remove(observer);
        }

        public void Notify()
        {
            foreach (var observer in observers)
            {
                observer.Update();
            }
        }
    }

    public class SubjectA : Subject
    {
        private string selfState;
        public string SelfState {
            set {
                selfState = value;
                Notify();
            }
            get
            {
                return selfState;
            }
        }
    }

    public interface IObserver
    {
        void Update();
    }

    public class ObserverA : IObserver
    {
        public void Update()
        {
            //todo
        }
    }

    public class ObserverB : IObserver
    {
        public void Update()
        {
            //todo
        }
    }

    public class Test
    {
        public Test()
        {
            SubjectA subjectA = new SubjectA();
            subjectA.Add(new ObserverA());
            subjectA.Add(new ObserverB());
            subjectA.SelfState = "aaa";
        }
    }

四 优缺点

4.1 优点

1. 低耦合， 被观察者与观察者都依赖抽象， 被观察者只需维护一个抽象观察者列表， 不需要知道具体的观察者是谁。
2. 符合依赖倒转原则。

4.2 缺点

1. 如果一个被观察者有很多的观察者， 可能通知到观察者的耗时会比较长。
2. 需要注意观察者列表的维护。

五 事件委托实现

  public delegate void Update();
    public interface ISubject
    {
        void Notify();
        void Add(Update func);
        void Remove(Update func);
    }

    public class Subject : ISubject
    {
        private event Update update;

        public void Add(Update func)
        {
            update += func;
        }

        public void Notify()
        {
            update();
        }

        public void Remove(Update func)
        {
            update -= func;
        }

    }

    public interface IObserver
    {
        void Update();
    }

    public class ObserverA : IObserver
    {
        public void Update() {
        }
    }
    public class ObserverB : IObserver
    {
        public void Update()
        {
        }
    }

    public class Test{
        public Test()
        {
            ISubject subject = new Subject();
            IObserver observerA = new ObserverA();
            IObserver observerB = new ObserverB();
            subject.Add(observerA.Update);
            subject.Add(observerB.Update);
            subject.Notify();
        }
    }

六 使用场景

1. 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
2. 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。