Design patterns 中介模式与创新

在一个演示中，我有几个“小部件”需要相互交互，但是交互已经变得足够复杂，需要一个新对象来处理交互

在试图通过中介作为对象工作时，我对如何有效地构建参与者感到困惑。中介必须知道小部件，小部件必须知道中介

使用下面的玩具类，有人能告诉我构造函数是什么样子的，以及它们通常是以什么顺序创建的吗

干杯，
贝里尔

---

您没有指定语言，因此我将尽可能保留它的通用性

abstract class Participant {
    public string Notify(string message);
}

---

---

---

---

因此，在高层次上，您有两个参与者想要发言，因此您需要设置一个公共界面来进行对话

我们创建一个方法调用Notify（message）；这基本上是你的沟通渠道

为了进行设置，我们实例化一个中介，然后实例化两个参与者，并将中介传递给他们

insetup的最后一步是注入/设置中介参与者。在我们的例子中，我们只使用简单的setter

当需要进行交流时，每个参与者只需调用中介，将消息和self作为参数传递

调解人看谁联系了他们，然后打电话给对方

请让我知道如果你有任何问题，有明显的许多变化，这种模式，所以让我知道，如果有其他东西，你想看看

---

注意。

这取决于其他一些情况，但我可能会这样做：

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

    void setWidgetOne(WidgetOne one){_widgetOne = one;}
    void setWidgetTwo(WidgetTwo one){_widgetTwo = one;}            
}

class WidgetOne {
    Mediator me
    void WidgetOne(Mediator me){
        this.me = me
        me.setWidgetOne(this);
    }
}

class WidgetTwo {
    Mediator me
    void WidgetTwo(Mediator me){
        this.me = me
        me.setWidgetTwo(this);
    }
}

Mediator me = new Mediator();
WidgetOne one = new WidgetOne(me);
WidgetTwo two = new WidgetTwo(me);

当然，如果没有其他需要知道的关于小部件的信息，那么我会去掉setter，只需要这样：

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

     void Mediator(){
        _widgetOne = new WidgetOne(this);
        _widgetTwo = new WidgetTwo(this);
     }            
}

class WidgetOne {
    Mediator me
    void WidgetOne(Mediator me){
        this.me = me
    }
}

class WidgetTwo {
    Mediator me
    void WidgetTwo(Mediator me){
        this.me = me
    }
}

简单地说，还有一些其他的。。。简表：

// Factory:

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

     void Mediator(){
        _widgetOne = WidgetFactory.getW1(this);
        _widgetTwo = WidgetFactory.getW2(this);
     }            
}

class W1 {
    Mediator me
    void W1(){
    }
    void setMediator(Mediator med){me = med}
}

class WidgetFactory {
    W1 getW1(Mediator me){ W1 w = new W1(); w.setMediator(me); return me}
}


// Centralized "model" (variant of factory)
class Mediator {
   W1 w1;

   static Mediator getInstance(){ return inst; }// See Singleton

   void registerW1(W1 w){w1 = w; w.setMediator(this);}
}

---

是的，我喜欢。我很惊讶，我在谷歌搜索过的任何一个明显的网站上都没有看到这个问题的产生，尽管我很确定GoF已经涵盖了它。你能不能把脑海中浮现的其他一些情况抛诸脑后？令人愉快的回答。我也在考虑使用某种观察器模式，但对于给定的演示文稿来说，它的耦合似乎太松散了（我正在用c#做一些MVVM类型的东西）。我需要再努力一点。干杯你总是可以做到的，有时当我必须说明如何使用中介时，我会展示一个利用观察者模式+中介的pub-sub风格的系统。您基本上可以执行mediator.send（from、topic、message）之类的操作，然后执行subscribe/register之类的操作来设置观察者。

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;
    public void setWidgetOne(WidgetOne theWidget){
        _wiidgetOne = theWidget;
    }
    public void setWidgetTwo(WidgetTwo theWidget){
        _wiidgetTwo = theWidget;
    }
    public string Talk(string message, Participant p){
           #make sure you do the correct ==/equals/etc.
          if(p == _widgetOne){
              response = _widgetTwo.Notify(message);    
          }else if (p == _widgetTwo){
               response  = _widgetOne.Notify(message);
          }
          return response;
    }

}

class Main {
    public void run(){
       Mediator theMediator = new Mediator();
       WidgetOne  one = new WidgetOne(theMediator);
       WidgetTwo  two = new WidgetTwo(theMediator);
       theMediator.setWidgetOne(one);
       theMediator.setWidgetTwo(two);
       one.Talk("hi there");
    }
}

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

    void setWidgetOne(WidgetOne one){_widgetOne = one;}
    void setWidgetTwo(WidgetTwo one){_widgetTwo = one;}            
}

class WidgetOne {
    Mediator me
    void WidgetOne(Mediator me){
        this.me = me
        me.setWidgetOne(this);
    }
}

class WidgetTwo {
    Mediator me
    void WidgetTwo(Mediator me){
        this.me = me
        me.setWidgetTwo(this);
    }
}

Mediator me = new Mediator();
WidgetOne one = new WidgetOne(me);
WidgetTwo two = new WidgetTwo(me);

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

     void Mediator(){
        _widgetOne = new WidgetOne(this);
        _widgetTwo = new WidgetTwo(this);
     }            
}

class WidgetOne {
    Mediator me
    void WidgetOne(Mediator me){
        this.me = me
    }
}

class WidgetTwo {
    Mediator me
    void WidgetTwo(Mediator me){
        this.me = me
    }
}

// Factory:

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

     void Mediator(){
        _widgetOne = WidgetFactory.getW1(this);
        _widgetTwo = WidgetFactory.getW2(this);
     }            
}

class W1 {
    Mediator me
    void W1(){
    }
    void setMediator(Mediator med){me = med}
}

class WidgetFactory {
    W1 getW1(Mediator me){ W1 w = new W1(); w.setMediator(me); return me}
}


// Centralized "model" (variant of factory)
class Mediator {
   W1 w1;

   static Mediator getInstance(){ return inst; }// See Singleton

   void registerW1(W1 w){w1 = w; w.setMediator(this);}
}