⭐️C#基础知识学习⭐️| 编程 设计模式界的”网红”——观察者模式

前言

前边有一篇文章简单介绍了23中设计模式和六大设计原则。原文///C#进阶知识学习 之 ☀️ 带你认识编程中的—23种设计模式 & 六大设计原则
在这里就挑几种常用的设计模式来做一个单独的详情介绍 ，就比如本篇文章的主角——观察者模式

观察者模式📢

观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

很多观察者想要观察被观察者的状态，因此委托一个通知者去观察，观察到变化后，通知给所有参与的观察者

核心类说明：
Subject： 抽象主题，即为被观察对象，本身维护一个观察者集合。
Observer： 抽象观察者，根据主题状态变化做出相应反应，本身维护一个主题的引用。

观察者模式的优点

• Subject和Observer之间是松偶合的，分别可以各自独立改变(它把观察者与被观察者分离，并将二者间的关系通过抽象观察者和抽象被观察者联系在一起，当一方发生变化时不会影响另一方的执行，从而降低了程序的耦合。)。
• 可以支持多种不同的具体观察者实现，有利于程序的扩展。
• 观察者的数目是可变的，主题可以实现动态的增加或移除观察者对象。
• Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。
• 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。
• 被观察者在自身状态发生变化时，会主动通知观察者，如果不是被观察者主动通知，那就需要观察者通过定时任务的方式来监控被观察者的状态是否发生变化，被观察者主动通知的方式要比观察者定时监控方式性能更高。
• 观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知，

观察者模式的缺点

• 1、松偶合导致代码关系不明显，有时可能难以理解。
• 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
• 如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察者模式是要特别注意这一点。
• 如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。
• 虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。
• 观察者模式是一种常用的触发机制，它形成一条触发链，依次对各个观察者的方法进行处理。但同时，这也算是观察者模式一个缺点，由于是链式触发，当观察者比较多的时候，性能问题是比较令人担忧的。并且，在链式结构中，比较容易出现循环引用的错误，造成系统假死。

举例说明👽

下面举两个例子来看一下
例1：

    /// <summary>
    /// 抽象主题类
    /// </summary>
    public abstract class Subject
    {
   
        private List<Observer> observers;
        public Subject()
        {
   
            this.observers = new List<Observer>();
        }
        protected void Notify()
        {
   
            foreach (var item in observers)
            {
   
                item.Response();
            }
        }
        public void Register(Observer ob)
        {
   
            observers.Add(ob);
        }
    }
    /// <summary>
    /// 具体主题类，世界卫生组织
    /// </summary>
    public class WHO : Subject
    {
   
        public void Warning()
        {
   
            Console.WriteLine("新冠病毒传染性强，注意防范！！！");
            Notify();
        }
    }
    /// <summary>
    /// 抽象观察类
    /// </summary>
    public abstract class Observer
    {
   
        public abstract void Response();
    }
    /// <summary>
    /// 具体观察类，中国
    /// </summary>
    public class China : Observer
    {
   
        public override void Response()
        {
   
            Console.WriteLine("中国：");
            Console.WriteLine("全民带口罩");
            Console.WriteLine("认真落实防疫策略");
            Console.WriteLine("帮助他国共同战疫");
        }
    }
    /// <summary>
    /// 具体观察类，美国
    /// </summary>
    public class America : Observer
    {
   
        public override void Response()
        {
   
            Console.WriteLine("特朗普：");
            Console.WriteLine("我们做的很好");
            Console.WriteLine("死亡人数在20万以内");
            Console.WriteLine("注射消毒水消灭病毒");
        }
}


        static void Main(string[] args)
        {
   
            WHO who = new WHO();
            China china = new China();
            America american = new America();
            who.Register(china);
            who.Register(american);
            who.Warning();
            Console.Read();
        }

打印结果如下：

例子2：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public abstract class ObserverAb
{
   
    public abstract void ReceiveMsg(string msg);
  
}
public abstract class SubjectAb
{
   
    protected IList<ObserverAb> observes;
    public abstract void AddObserver(ObserverWaitMsg observer);
    public abstract void RemoveObserver(ObserverWaitMsg observer);

    public abstract void Notify(string msg);
}

/// <summary>
///     观察者等待消息
/// </summary>
public class ObserverWaitMsg:ObserverAb
{
   
    public string name;
    public ObserverWaitMsg(string name)
    {
   
        this.name = name;
    }
    public override  void ReceiveMsg(string msg)
    {
   
        Debug.Log(name + "收到了消息：" + msg);
    }
}
/// <summary>
/// 通知者发送消息
/// </summary>
public class SubjectSendMsg :SubjectAb
{
   
    public SubjectSendMsg()
    {
   
        observes =new List<ObserverAb>();
    }
    public override  void AddObserver(ObserverWaitMsg observer)
    {
   
        if (!observes.Contains(observer))
        {
   
            observes.Add(observer);
        }
    }
    public override void RemoveObserver(ObserverWaitMsg observer)
    {
   
        if (observes.Contains(observer))
        {
   
            observes.Remove(observer);
        }
    }

    /// <summary>
    /// 通知方法
    /// </summary>
    /// <param name="msg"></param>
    public override  void Notify(string msg)
    {
   
        for (int i = 0; i <observes.Count  ; i++)
        {
   
            //通知给每个观察者
            observes[i].ReceiveMsg(msg);
        }
    }

    public void WatchGameTime(float targetTime,float currentTime)
    {
   
        if (currentTime>=targetTime )
        {
   
            Notify("挂机任务完成了");
        }
    }
}
public class ObserverDemo : MonoBehaviour
{
   
    //普通任务观察者
    private ObserverWaitMsg normalTask;
    //成就任务观察者
    private ObserverWaitMsg achievementTask;

    private SubjectSendMsg subject;

    private void Start()
    {
   
        normalTask = new ObserverWaitMsg("普通任务观察者");
        achievementTask = new ObserverWaitMsg("成就任务观察者");
        subject = new SubjectSendMsg();

        //添加观察者到观察者列表
        subject.AddObserver(normalTask);
        subject.AddObserver(achievementTask);

        //移除成就任务观察者
        subject.RemoveObserver(achievementTask);
    }


    private void Update()
    {
   
        //通知者（具体通知者）具体观察者每帧进行时间监测
        subject.WatchGameTime(5,Time.deltaTime);
    }
}

到5秒时间后就会执行

总结💬

当一个对象的改变需要同时改变其他对象的时候，可以考虑使用观察者模式。

转载：https://blog.csdn.net/zhangay1998/article/details/116791704