static void Main(string[] args)
{
IColleague colleague1 = new Colleague1();
IColleague colleague2 = new Colleague2();
IMediator mediator = new ConcreteMediator1(colleague1, colleague2);
mediator.ChangeState("new input");
}
public override void Declare(string message, Country colleague)
{
if (colleague == Colleague1)
{
Colleague2.GetMessage(message);
}
else
{
Colleague1.GetMessage(message);
}
}
public void SendMessage(Colleague caller, string msg)
{
if (caller == Colleague1)
{
Colleague2.Receive(msg);
}
else
{
Colleague1.Receive(msg);
}
}
//TODO: Manage send method with real collegues
public void sendMessage(string msg, Colleague colleague)
{
if (Colleague1 == colleague)
{
Colleague2.Notify(msg);
}
else
{
Colleague1.Notify(msg);
}
}
public override void Send(string msg, Colleague colleague)
{
if (Colleague1 == colleague)
{
Colleague2.Notify(msg);
}
else
{
Colleague1.Notify(msg);
}
}
public override void Send(string message, Colleague colleague)
{
if (colleague == Colleague1)
{
Colleague2.Notify(message);
}
else
{
Colleague1.Notify(message);
}
}
public void Send(Colleague colleague, string message)
{
if (colleague == Colleague1)
{
Colleague2.Notify(message);
}
else
{
Colleague1.Notify(message);
}
}
public void SendMessage(ConversetionParticipents caller, string msg)
{
if (caller == Colleague1)
{
Colleague2.Receive(msg);
}
else
{
Colleague1.Receive(msg);
}
}
public override void Send(string msg, AbstractColleague colleague)
{
if (colleague == Colleague1)
{
Colleague2.Notify(msg);
}
else
{
Colleague1.Notify(msg);
}
}
static void MediatorExample()
{
var mediator = new ConcreteMediator();
var colleague1 = new Colleague1(mediator);
var colleague2 = new Colleague2(mediator);
mediator.Colleague1 = colleague1;
mediator.Colleague2 = colleague2;
colleague1.Send($"Hello {nameof(Colleague2)}!");
colleague2.Send($"Hello {nameof(Colleague1)}!");
}
private void Start()
{
ColleagueMediator cm = new ColleagueMediator();
Colleague1 c1 = new Colleague1(cm);
Colleague2 c2 = new Colleague2(cm);
cm.SetColleague1(c1);
cm.SetColleague2(c2);
c1.C1Action();
c2.C2Action();
}
public void SendMessage(Colleague caller, KeyValuePair <string, object> valuePair)
{
// Open-closed principle
if (caller == Colleague1)
{
Colleague2.Receive(valuePair);
}
else
{
Colleague1.Receive(valuePair);
}
}
/// <summary>
/// Method signature for sending messages to another colleague.
/// </summary>
/// <param name="message">Message to send.</param>
/// <param name="col">Colleague to send to.</param>
/// <returns><c>bool</c> - returns that message was sent and received.</returns>
public override bool Send(string message, Colleague col)
{
if (col == Colleague1)
{
return(Colleague1.Notify(message));
}
if (col == Colleague2)
{
return(Colleague2.Notify(message));
}
// No colleagues found.
return(false);
}
/// <summary>
/// The main.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
public static void Main(string[] args)
{
var mediator = new Mediator();
/* var colleague1 = new Colleague1();
* var colleague2 = new Colleague2();
*
* mediator.Register(colleague1);
* mediator.Register(colleague2); */
Colleague1 colleague1 = mediator.CreateColleague <Colleague1>();
Colleague2 colleague2 = mediator.CreateColleague <Colleague2>();
colleague1.Send($"Hello Word from colleague 1");
colleague2.Send($"Hello Word from colleague 2");
}
static void Main(string[] args)
{
var mediator = new ConcreteMediator();
var c1 = new Colleague1();
var c2 = new Colleague2();
//mediator.Colleague1 = c1;
//mediator.Colleague2 = c2;
mediator.Register(c1);
mediator.Register(c2);
c1.Send("Hello from c1");
c2.Send("Hola from c2");
//mediator.Send("Hola", c2);
}
public void Run()
{
var mediator = new ConcreteMediator();
var c1 = new Colleague1(mediator);
var c2 = new Colleague2(mediator);
mediator.Colleague1 = c1;
mediator.Colleague2 = c2;
//mediator.Register(c1);
//mediator.Register(c2);
//var c1 = mediator.CreateCollegue<Colleague1>();
//var c2 = mediator.CreateCollegue<Colleague2>();
c1.Send("Hello c2!");
c2.Send("Hello c1!");
}
/// <summary>
/// send a message to the colleague
/// </summary>
/// <param name="sender">IColleague:: the sender's object</param>
/// <param name="initMessage">string:: the message</param>
/// <exception cref="ArgumentNullException">thrown when sender is null.</exception>
/// <exception cref="ArgumentException">thrown when sender is not one of the two mediated object</exception>
public void Notify(IMediatedObject sender, string initMessage)
{
if (sender == null)
{
throw new ArgumentNullException(nameof(sender));
}
if (sender == Colleague1)
{
Colleague2.ActOnNotify(initMessage);
}
else if (sender == Colleague2)
{
Colleague1.ActOnNotify(initMessage);
}
else
{
throw new ArgumentException("sender is not a mediated object. ");
}
}
private static void Main(string[] args)
{
IHandler handler = new Handler();
IMediator mediator = new Mediator();
AbstractListener listener1 = new Colleague1();
AbstractListener listener2 = new Colleague2();
AbstractListener listener3 = new Colleague3();
try
{
mediator.AddListener(listener1, "OnEvent");
mediator.AddListener(listener2, "OnEvent");
mediator.AddListener(listener3, "OnEvent");
listener1.ToGreet(listener2.GetType().Name, mediator, handler);
listener2.ToGreet(listener3.GetType().Name, mediator, handler);
listener3.ToGreet(listener1.GetType().Name, mediator, handler);
}
catch (Exception e)
{
Console.WriteLine("Caught exception: {0} \n", e.Message);
}
}
public void SetColleague1(Colleague1 c)
{
c1 = c;
}
