设计模式-观察者设计模式

来源：cnblogs　　作者：冰乐　　时间：2019/9/20 9:49:32　　对本文有异议

一个对象的动作触发多个对象的行为，通过观察者可以去掉对象的依赖，支持各种自定义和扩展。

观察者模式，还要从那只申请的猫开始说起。

猫叫一声之后触发：

　　Baby Cry（）、Brother Trun（）、Dog Wang（）、Father Roar（）、Mothor Whisper（）、Mouse Run（）、Neighbour Awake（）、Stealer Hide（）.......

下面代码是这些触发类：

public class Baby 
{
    public void Cry()
    {
        Console.WriteLine("{0} Cry", this.GetType().Name);
    }
}
public class Brother
{
    public void Turn()
    {
        Console.WriteLine("{0} Turn", this.GetType().Name);
    }
}
 public class Chicken
 {
     public void Woo()
     {
         Console.WriteLine("{0} Woo", this.GetType().Name);
     }
 }
 public class Dog 
 {
     public void Wang()
     {
         Console.WriteLine("{0} Wang", this.GetType().Name);
     }
 }
 public class Father
 {
     public void Roar()
     {
         Console.WriteLine("{0} Roar", this.GetType().Name);
     }
 }
public class Mother
{
    public void Whisper()
    {
        Console.WriteLine("{0} Whisper", this.GetType().Name);
    }
}
public class Mouse 
{
    public void Run()
    {
        Console.WriteLine("{0} Run", this.GetType().Name);
    }
}
 public class Neighbor
 {
     public void Awake()
     {
         Console.WriteLine("{0} Awake", this.GetType().Name);
     }
 }
public class Stealer 
{
    public void Hide()
    {
        Console.WriteLine("{0} Hide", this.GetType().Name);
    }
}

View Code

然后，猫叫一声，触发这些动作：

 public class Cat
 {
     public void Miao()
     {
         Console.WriteLine("{0} Miao.....", this.GetType().Name);
         new Mouse().Run();//依赖
         new Chicken().Woo();
         new Baby().Cry();
         new Brother().Turn();
         new Dog().Wang();
         new Father().Roar();
         new Mother().Whisper();
         //new Mouse().Run();
         new Neighbor().Awake();
         //new Stealer().Hide();
     }
}

这样写，功能是实现了，但是依赖太多，任何一个对象改动，都会导致Cat类变化，违背了单一职责，不仅自己Miao，还要触发各种动作，不稳定，加一个/减一个/调整顺序，Cat都得改。

Cat职责：

　　1、Miao（）

　　2、触发一些列动作，这其实就是需求

　　3、实现上，其实多了一个，指定动作

Cat不稳定的原因，在Miao（）方法里面的一些对象。

这个时候就要甩锅大法了，把锅丢出去与，只管自己，把不稳定的地方移出去，自己只写稳定的，这样能保证自身的稳定。

定义一个接口，把这些动作抽象出一个Action（），只是为了把多个对象产生关系，方便保存和调用，方法本身其实没用的：

public interface IObserver
{
    void Action();
}

让上面那些Miao一声后需要触发的动作类，实现这个接口：

public class Baby : IObserver
{
    public void Action()
    {
        this.Cry();
    }
    public void Cry()
    {
        Console.WriteLine("{0} Cry", this.GetType().Name);
    }
}
public class Brother : IObserver
{
    public void Action()
    {
        this.Turn();
    }
    public void Turn()
    {
        Console.WriteLine("{0} Turn", this.GetType().Name);
    }
}
 public class Chicken : IObserver
 {
     public void Action()
     {
         this.Woo();
     }
     public void Woo()
     {
         Console.WriteLine("{0} Woo", this.GetType().Name);
     }
 }
public class Dog : IObserver
{
    public void Action()
    {
        this.Wang();
    }
    public void Wang()
    {
        Console.WriteLine("{0} Wang", this.GetType().Name);
    }
}
public class Father : IObserver
{
    public void Action()
    {
        this.Roar();
    }
    public void Roar()
    {
        Console.WriteLine("{0} Roar", this.GetType().Name);
    }
}
public class Mother : IObserver
{
    public void Action()
    {
        this.Whisper();
    }
    public void Whisper()
    {
        Console.WriteLine("{0} Whisper", this.GetType().Name);
    }
}
 public class Mouse : IObserver
 {
     public void Action()
     {
         this.Run();
     }
     public void Run()
     {
         Console.WriteLine("{0} Run", this.GetType().Name);
     }
 }
 public class Neighbor : IObserver
 {
     public void Action()
     {
         this.Awake();
     }
     public void Awake()
     {
         Console.WriteLine("{0} Awake", this.GetType().Name);
     }
 }
 public class Stealer : IObserver
 {
     public void Action()
     {
         this.Hide();
     }
     public void Hide()
     {
         Console.WriteLine("{0} Hide", this.GetType().Name);
     }
 }

View Code

Cat这个类就可以修改成如下，使用集合或者事件都是可以的：

public class Cat
{
    //Cat不稳定--这一堆对象--甩锅--自己不写让别人传递
    private List<IObserver> _ObserverList = new List<IObserver>();
    public void AddObserver(IObserver observer)
    {
        this._ObserverList.Add(observer);
　　　　　MiaoHandler += observer.Action;
    }
    public void MiaoObserver()
    {
        Console.WriteLine("{0} MiaoObserver.....", this.GetType().Name);
        if (this._ObserverList != null && this._ObserverList.Count > 0)
        {
            foreach (var item in this._ObserverList)
            {
                item.Action();
            }
        }
    }
    private event Action MiaoHandler;
    public void MiaoEvent()
    {
        Console.WriteLine("{0} MiaoEvent.....", this.GetType().Name);
        if (this.MiaoHandler != null)
        {
            foreach (Action item in this.MiaoHandler.GetInvocationList())
            {
                item.Invoke();
            }
        }
    }
}

这样在调用的时候，增加一个，减少一个，更改顺序，就不要再去修改Cat类了。

 Cat cat = new Cat();
 cat.AddObserver(new Chicken());
 cat.AddObserver(new Baby());
 cat.AddObserver(new Brother());
 cat.AddObserver(new Dog());
 cat.AddObserver(new Father());
 cat.AddObserver(new Mother());
 cat.AddObserver(new Mouse());
 cat.AddObserver(new Neighbor());
 cat.AddObserver(new Stealer());
 cat.MiaoObserver();