读书笔记20：中介者模式

来源：互联网发布：ubuntu鼠标指针主题编辑：程序博客网时间：2024/05/29 10:00

1、定义：用一个中介对象来封装一系列的对象交互。中介者使个对象不需要显示地相互引用，从而使其耦合松散而且可以独立地改变它们之间的交互。
中介者减少了各个同事对象的耦合，使得可以独立地改变和复用各个同事对象和中介者类；由于把对想如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到他们之间的交互上来，也就是站在一个更宏伟的角度去考虑系统。
2、角色
Mediator——中介，其它类的互相访问，通过这个来实现。
Colleage——需要通信的类。
3、模型

抽象的两个角色。

[csharp] view plaincopyprint?
public abstract class Mediator  
{  
    public abstract void Send(string message,Colleage colleage);  
}  
  
public abstract class Colleage  
{  
    protected Mediator mediator;  
  
    public Colleage(Mediator mediator)  
    {  
        this.mediator = mediator;  
    }  
}  

中介类。需要通信的类在这里完成操作，避免了类之间互相引用。

[csharp] view plaincopyprint?
public class CreateMediator : Mediator  
{  
    private CreateColleage1 colleage1;  
  
    private CreateColleage2 colleage2;  
  
    public CreateColleage1 Colleage1  
    {  
        set   
        {   
            colleage1 = value;   
        }  
    }  
  
    public CreateColleage2 Colleage2  
    {  
        set   
        {   
            colleage2 = value;   
        }  
    }  
  
    public override void Send(string message, Colleage colleage)  
    {  
        if (colleage == colleage1)  
        {  
            colleage2.Notify(message);  
        }  
        else  
        {  
            colleage1.Notify(message);  
        }  
    }  
}  

需要相互操作的类。

[csharp] view plaincopyprint?
public class CreateColleage1:Colleage  
{  
    public CreateColleage1(Mediator mediator)  
  
        : base(mediator)  
    {  
  
    }  
  
    public void Send(string message)  
    {  
        mediator.Send(message, this);  
    }  
  
    public void Notify(string message)  
    {  
        Console.WriteLine(string.Format(@"同事1得到信息：{0}", message));  
    }  
}  
  
public class CreateColleage2 : Colleage  
{  
    public CreateColleage2(Mediator mediator)  
  
        : base(mediator)  
    {  
  
    }  
  
    public void Send(string message)  
    {  
        mediator.Send(message, this);  
    }  
  
    public void Notify(string message)  
    {  
        Console.WriteLine(string.Format(@"同事2得到信息：{0}", message));  
    }  
}  

调用

[csharp] view plaincopyprint?
static void Main()  
{  
    CreateMediator mediator = new CreateMediator();  
  
    CreateColleage1 colleage1 = new CreateColleage1(mediator);  
  
    CreateColleage2 colleage2 = new CreateColleage2(mediator);  
  
    mediator.Colleage1 = colleage1;  
  
    mediator.Colleage2 = colleage2;  
  
    colleage1.Send("吃了吗？");  
  
    colleage2.Send("没呢！");  
  
    Console.ReadLine();  
}  

结果：

中介者模式，是为了避免类之间的耦合，该模式把类与类之间的相互引用或者调用，都交给中介来完成。如下面的例子。
有一个窗体，窗体上面是要显示和操作数据的，比如读取数据库的数据显示出来、读取设置的数据来完成一些功能。要如下实现。

[csharp] view plaincopyprint?
public partial class Form1 : Form  
{  
    GetDataBaseData getDataBaseData;//读取数据库的类  
  
    GetSettingData getSettingData;//读取设置信息的类  
  
    public Form1()  
    {  
        InitializeComponent();  
    }  
}  
public class GetDataBaseData  
{  
    //方法  
}  
public class GetSettingData  
{  
    //方法  
 }  

这样有一个问题，如果还有别的获取数据的类呢，岂不是要一直在Form1中增加定义？这不符合三层架构。这样，需要修改一下，增加一个窗口管理类，

[csharp] view plaincopyprint?
public class Form1Manager  
{  
    GetDataBaseData getDataBaseData;//读取数据库的类  
  
    GetSettingData getSettingData;//读取设置信息的类  
  
    public object GetDataBaseData()   
    {  
        return "";  
    }  
  
    public object GetSettingData()  
    {  
        return "";  
    }  
}  
public partial class Form1 : Form  
{  
    Form1Manager form1Manager;  
  
    public Form1()  
    {  
        InitializeComponent();  
    }  
}  

Form1不管要获取什么数据，都交给管理类去获取，Form1只关心结果，至于管理类的算法什么的，就不去管了。这样管理类就充当了中介的角色。降低了窗体和数据类之间的耦合程度。
代码：http://download.csdn.net/detail/yysyangyangyangshan/4145501

0 0