[学习笔记：设计模式] 22_中介者模式

定义：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

---

中介者模式包含如下角色：

Mediator（抽象中介者）：在里面定义各个同事之间交互需要的方法，可以是公共的通信方法，也可以是小范围的交互方法。

ConcreteMediator（具体中介者）：它需要了解并维护各个同事对象，并负责具体的协调各同事对象的交互关系。

Colleague（抽象同事类）：通常为抽象类，主要约束同事对象的类型，并实现一些具体同事类之间的公共功能，比如，每个具体同事类都应该知道中介者对象，也就是具体同事类都会持有中介者对象，都可以到这个类里面。

ConcreteColleague（具体同事类）：实现自己的业务，需要与其他同事通信时候，就与持有的中介者通信，中介者会负责与其他同事类交互。

---

举例
聊天室给另一个人发消息，或者给所有人发消息

- 抽象中介者

abstract class Mediator
    {
        //登记成员
        public abstract void Register(Member member);

        //给其他成员单独发消息
        public abstract void DispatcherMessage(Member from, Member to, String message);

        //群发
        public abstract void SendToAll(Member self, String message);
    }

- 具体中介者

class ConcreteMediator :Mediator
    {
        private HashSet<Member> members = new HashSet<Member>();

        public override void Register(Member member)
        {
            members.Add(member);
        }

        public override void DispatcherMessage(Member from, Member to, String message)
        {
            message = message.Replace("日", "*");  //屏蔽部分语言
            to.ReceiveMessage(from, message);  //调用同事类中现有方法
        }

        public override void SendToAll(Member self, string message)
        {
            //给除自己外所有角色发送消息
            foreach(Member m in members)
            {
                if (m != self)
                {
                    Console.WriteLine(self.Name + " to " + m.Name + ": " + message);
                }
            }
        }
    }

- 抽象同事类

abstract class Member
    {
        private String name;

        protected Mediator mediator; //Colleague聚合Mediator

        public string Name { get => name; set => name = value; }

        public Member(String name)
        {
            this.Name = name;
        }

        public void SetMediator(Mediator mediator)
        {  
            this.mediator = mediator;
        }

        public void ReceiveMessage(Member from, String message)
        {
            Console.WriteLine(from.Name + " to " + Name + "：" + message);
        }

        public abstract void SendMessage(Member to, String message);  //私发
        public abstract void SendToAll(String message);  //群发
    }

- 具体同事类

class ConcreteMember : Member
    {
        public ConcreteMember(String name):base(name)
        {
            
        }

        public override void SendMessage(Member to, String message)
        {
            //调用中介者的转发消息方法
            mediator.DispatcherMessage(this, to, message);
        }

        public override void SendToAll(string message)
        {
            mediator.SendToAll(this, message);
        }
    }

- 客户类

class Program
    {
        static void Main(string[] args)
        {
            Mediator mediator = new ConcreteMediator();  //创建一个中介者

            Member member1, member2, member3;  //创建若干会员并注册
            member1 = new ConcreteMember("张三");
            member1.SetMediator(mediator);  //设置中介者
            mediator.Register(member1);  //中介者中登记成员
            member2 = new ConcreteMember("李四");
            member2.SetMediator(mediator);
            mediator.Register(member2);
            member3 = new ConcreteMember("王五");
            member3.SetMediator(mediator);
            mediator.Register(member3);

            //会员通过中介者转发消息
            member1.SendMessage(member2, "李四，你好！");
            member2.SendMessage(member1, "张三，你好！");
            member1.SendMessage(member3, "今日天气不错！");

            //群发消息
            member1.SendToAll("大家向我看齐，我宣布个事");
        }          
    }

总结：抽象中介者中定义成员之间的交互方法，具体中介者可根据需要增加行为或限制条件，抽象同事类中声明同事类的各种方法，并可实现部分公有方法，具体同事类则实现抽象同事类中定义的抽象方法，均可调用具体中介者中的方法。