中介者模式

• using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;
  
  //抽象中介者类
  public abstract class Mediator
  {
      /// <summary>
      /// 定义一个抽象的发送消息的方法
      /// </summary>
      /// <param name="message">发送消息</param>
      /// <param name="colleague">得到同时对象</param>
      public abstract void Send(string message, Colleague colleague);
  }
  
  //具体中介者类
  public class ConcreateMediator : Mediator
  {
      //同事1的引用
      private ConcreteColleague1 concreteColleague1;
      //同事2的引用
      private ConcreteColleague2 concreteColleague2;
      //设置属性只写
      public ConcreteColleague1 ConcreteColleague1
      {
          set { concreteColleague1 = value; }
      }
      public ConcreteColleague2 ConcreteColleague2
      {
          set { concreteColleague2 = value; }
      }
      /// <summary>
      /// 重新发送消息的而方法 根据对象作出选择判断，通知对象
      /// </summary>
      /// <param name="message">消息</param>
      /// <param name="colleague">具体的同事对象</param>
      public override void Send(string message, Colleague colleague)
      {
          //如果是同事1发送的消息
          if (colleague == concreteColleague1)
          {
              //同事2进行接收
              concreteColleague2.Notify(message);
          }
          //如果是同事2发送的消息
          if (colleague == concreteColleague2)
          {
              concreteColleague1.Notify(message);
          }
      }
  }
  
  

  using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;
  
  // 抽象同事类
  public abstract class Colleague
  {
      //中介者的引用
      protected Mediator mediator;
      /// <summary>
      /// 构造函数得到中介者对象
      /// </summary>
      protected Colleague(Mediator mediator)
      {
          this.mediator = mediator;
      }
      /// <summary>
      /// 发送消息
      /// </summary>
      public abstract void SendMessage(string message);
      /// <summary>
      /// 接收消息
      /// </summary>
      public abstract void Notify(string message);
  }
  
  // 同事1
  public class ConcreteColleague1 : Colleague
  {
      public ConcreteColleague1(Mediator mediator) : base(mediator)
      {
  
      }
      /// <summary>
      /// 接收消息
      /// </summary>
      public override void Notify(string message)
      {
          Debug.Log("同事1得到消息:" + message);
      }
      /// <summary>
      /// 发送消息
      /// </summary>
      public override void SendMessage(string message)
      {
          //发送消息时通常是中介者发送出去的
          mediator.Send(message, this);
      }
  }
  // 同事2
  public class ConcreteColleague2 : Colleague
  {
      public ConcreteColleague2(Mediator mediator) : base(mediator)
      {
  
      }
      /// <summary>
      /// 接收消息
      /// </summary>
      public override void Notify(string message)
      {
          Debug.Log("同事2得到消息:" + message);
      }
      /// <summary>
      /// 发送消息
      /// </summary>
      public override void SendMessage(string message)
      {
          //发送消息时通常是中介者发送出去的
          mediator.Send(message, this);
      }
  }

  using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;
  
  public class Test : MonoBehaviour
  {
      private ConcreateMediator concreateMediator;
      private ConcreteColleague1 colleague1;
      private ConcreteColleague2 colleague2;
      void Start()
      {
          concreateMediator = new ConcreateMediator();
          //让两个具体的同事类持有中介者对象
          colleague1 = new ConcreteColleague1(concreateMediator);
          colleague2 = new ConcreteColleague2(concreateMediator);
          //让中介者持有各个具体同事类对象
          concreateMediator.ConcreteColleague1 = colleague1;
          concreateMediator.ConcreteColleague2 = colleague2;
          //具体同事类对象的发送消息都是通过中介者转发
          colleague1.SendMessage("同事1发的消息");
          colleague2.SendMessage("同事2发的消息");
      }
  }
  

  输出：

• 同事2得到消息:同事1发的消息

• 同事1得到消息:同事2发的消息