Wat is een mediator in de context van programmeren…

De mediator is een gedragsontwerppatroon dat een gecentraliseerd object voorstelt dat de interactie tussen andere objecten (collega's) beheert. In plaats van dat objecten rechtstreeks communiceren, interageren ze via de mediator.

Voordelen van het gebruik van de mediator:

Vermindering van koppeling: Objecten hebben geen directe verwijzingen naar elkaar, wat hun afhankelijkheid vermindert.
Vereenvoudiging van beheer: Interacties tussen objecten worden op één plek geconcentreerd, wat begrip en wijziging vergemakkelijkt.
Verbetering van hergebruik: Individuele componenten kunnen in andere contexten worden hergebruikt, omdat ze niet sterk gekoppeld zijn aan andere componenten.

Nadelen:

Toename van de complexiteit van de mediator: Naarmate het aantal interacties toeneemt, kan de mediator complex en moeilijk te onderhouden worden.
Mogelijke prestatievermindering: Alle interacties verlopen via een centraal object, wat extra overhead kan veroorzaken.

Voorbeeld van eenvoudige implementatie:

// Interface voor de mediator
public interface IMediator
{
    void SendMessage(string message, Colleague colleague);
}

// Basisklasse voor collega's
public abstract class Colleague
{
    protected IMediator mediator;

    public Colleague(IMediator mediator)
    {
        this.mediator = mediator;
    }

    public abstract void ReceiveMessage(string message);
    public abstract void Send(string message);
}

// Concrete mediator
public class ConcreteMediator : IMediator
{
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

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

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

    public void SendMessage(string message, Colleague colleague)
    {
        if (colleague == colleague1)
        {
            colleague2.ReceiveMessage(message);
        }
        else
        {
            colleague1.ReceiveMessage(message);
        }
    }
}

// Concrete collega's
public class ConcreteColleague1 : Colleague
{
    public ConcreteColleague1(IMediator mediator) : base(mediator) { }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Bericht ontvangen door collega 1: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Bericht verzonden door collega 1: {message}");
        mediator.SendMessage(message, this);
    }
}

public class ConcreteColleague2 : Colleague
{
    public ConcreteColleague2(IMediator mediator) : base(mediator) { }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Bericht ontvangen door collega 2: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Bericht verzonden door collega 2: {message}");
        mediator.SendMessage(message, this);
    }
}

// Voorbeeld van gebruik
// var mediator = new ConcreteMediator();
// var collega1 = new ConcreteColleague1(mediator);
// var collega2 = new ConcreteColleague2(mediator);
// mediator.Colleague1 = collega1;
// mediator.Colleague2 = collega2;
// collega1.Send("Hallo collega 2!");
// collega2.Send("Hallo collega 1!");

Wordt vaak samen met andere patronen, zoals Observer, gebruikt om complexere berichtenuitwissingssystemen te implementeren. In de context van .NET wordt het vaak toegepast in bibliotheken voor het werken met verzoeken en commando's, zoals MediatR.

Wat is een mediator in de context van programmeren?