设计模式5-观察者模式

观察者模式：一种一对多依赖关系，多个观察者对象同时监听一个对象，这个对象发生改变，会通知所有观察者对象，让他们来更新自己。

namespace DesignModel.观察者模式
{

    /// <summary>
    /// 抽象被观察者
    /// </summary>
    internal abstract class Source
    {
        private IList<AbsObserver> ts = new List<AbsObserver>();

        internal void Add(AbsObserver abss)
        {
             ts.Add(abss);
        }
        internal void Remove(AbsObserver abss)
        {
            ts.Remove(abss);
        }

        internal void Notify()
        {
            ts.ForEach(t =>
            {
                t.Update();
            });
        }
    }

    /// <summary>
    /// 具体被观察者
    /// </summary>
    class Teacher : Source
    {
        public string Name { get; set; }
        public string TeachWords { get; set; }
    }


    /// <summary>
    /// 抽象观察者
    /// </summary>
    abstract class AbsObserver
    {
        public abstract void Update();

    }
    /// <summary>
    /// 观察者
    /// </summary>
    class ObserA : AbsObserver
    {
        private Teacher Tearcher { get; set; }
        public string State { get; set; }
        public ObserA(Teacher t)//观察者与被观察者不得不耦合
        {
            Tearcher = t;
        }
        public override void Update()
        {
            //........do something for 'sync'
            this.State = Tearcher.TeachWords;
        }
    }


    
    static class Extends
    {
        public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
        {
            foreach (var item in source)
            {
                action(item);
            }
        }
    }
 

}

 static void 观察者模式()
        {
            var t = new Teacher();
            t.Add(new ObserA(t));
            //t.add(new ObserB(t));
            //......
            t.Name = "Liu";
            t.TeachWords = "hello world";
            t.Notify();
         }