Mediator Design Pattern

// Mediator pattern -- Structural example

using System;
using System.Collections;

namespace DoFactory.GangOfFour.Mediator.Structural
{

  // Mainapp test application

  class MainApp
  {
    static void Main()
    {
      ConcreteMediator m = new ConcreteMediator();

      ConcreteColleague1 c1 = new ConcreteColleague1(m);
      ConcreteColleague2 c2 = new ConcreteColleague2(m);

      m.Colleague1 = c1;
      m.Colleague2 = c2;

      c1.Send("How are you?");
      c2.Send("Fine, thanks");

      // Wait for user
      Console.Read();
    }
  }

  // "Mediator"

  abstract class Mediator
  {
    public abstract void Send(string message,
      Colleague colleague);
  }

  // "ConcreteMediator"

  class ConcreteMediator : Mediator
  {
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

    public ConcreteColleague1 Colleague1
    {
      set{ colleague1 = value; }
    }

    public ConcreteColleague2 Colleague2
    {
      set{ colleague2 = value; }
    }

    public override void Send(string message,
      Colleague colleague)
    {
      if (colleague == colleague1)
      {
        colleague2.Notify(message);
      }
      else
      {
        colleague1.Notify(message);
      }
    }
  }

  // "Colleague"

  abstract class Colleague
  {
    protected Mediator mediator;

    // Constructor
    public Colleague(Mediator mediator)
    {
      this.mediator = mediator;
    }
  }

  // "ConcreteColleague1"

  class ConcreteColleague1 : Colleague
  {
    // Constructor
    public ConcreteColleague1(Mediator mediator)
      : base(mediator)
    {
    }

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

    public void Notify(string message)
    {
      Console.WriteLine("Colleague1 gets message: "
        + message);
    }
  }

  // "ConcreteColleague2"

  class ConcreteColleague2 : Colleague
  {
    // Constructor
    public ConcreteColleague2(Mediator mediator)
      : base(mediator)
    {
    }

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

    public void Notify(string message)
    {
      Console.WriteLine("Colleague2 gets message: "
        + message);
    }
  }
}

using System;
using System.Collections;

namespace DoFactory.GangOfFour.Mediator.RealWorld
{
  
  // MainApp test application

  class MainApp
  {
    static void Main()
    {
      // Create chatroom
      Chatroom chatroom = new Chatroom();

      // Create participants and register them
      Participant George = new Beatle("George");
      Participant Paul = new Beatle("Paul");
      Participant Ringo = new Beatle("Ringo");
      Participant John = new Beatle("John") ;
      Participant Yoko = new NonBeatle("Yoko");

      chatroom.Register(George);
      chatroom.Register(Paul);
      chatroom.Register(Ringo);
      chatroom.Register(John);
      chatroom.Register(Yoko);

      // Chatting participants
      Yoko.Send ("John", "Hi John!");
      Paul.Send ("Ringo", "All you need is love");
      Ringo.Send("George", "My sweet Lord");
      Paul.Send ("John", "Can't buy me love");
      John.Send ("Yoko", "My sweet love") ;

      // Wait for user
      Console.Read();
    }
  }

  // "Mediator"

  abstract class AbstractChatroom
  {
    public abstract void Register(Participant participant);
    public abstract void Send(
      string from, string to, string message);
  }

  // "ConcreteMediator"

  class Chatroom : AbstractChatroom
  {
    private Hashtable participants = new Hashtable();

    public override void Register(Participant participant)
    {
      if (participants[participant.Name] == null)
      {
        participants[participant.Name] = participant;
      }

      participant.Chatroom = this;
    }

    public override void Send(
      string from, string to, string message)
    {
      Participant pto = (Participant)participants[to];
      if (pto != null)
      {
        pto.Receive(from, message);
      }
    }
  }

  // "AbstractColleague"

  class Participant
  {
    private Chatroom chatroom;
    private string name;

    // Constructor
    public Participant(string name)
    {
      this.name = name;
    }

    // Properties
    public string Name
    {
      get{ return name; }
    }

    public Chatroom Chatroom
    {
      set{ chatroom = value; }
      get{ return chatroom; }
    }

    public void Send(string to, string message)
    {
      chatroom.Send(name, to, message);
    }

    public virtual void Receive(
      string from, string message)
    {
      Console.WriteLine("{0} to {1}: '{2}'",
        from, Name, message);
    }
  }

  //" ConcreteColleague1"

  class Beatle : Participant
  {
    // Constructor
    public Beatle(string name) : base(name)
    {
    }

    public override void Receive(string from, string message)
    {
      Console.Write("To a Beatle: ");
      base.Receive(from, message);
    }
  }

  //" ConcreteColleague2"

  class NonBeatle : Participant
  {
    // Constructor
    public NonBeatle(string name) : base(name)
    {
    }

    public override void Receive(string from, string message)
    {
      Console.Write("To a non-Beatle: ");
      base.Receive(from, message);
    }
  }
}

// Mediator pattern -- .NET optimized

Two editions: C# and VB.NET

This .NET code is part of our unique Design Pattern Framework 2.0TM with: 69 gang-of-four pattern projects 46 head-first pattern projects Martin Fowler's enterprise patterns SOA design patterns e-commerce web application 100% pure source code Instant download. Order now!

         See our Singleton page for a .NET optimized code sample.