Qu'est-ce qu'un médiateur dans le contexte de la…

Le médiateur est un patron de conception comportemental qui propose un objet centralisé pour gérer l'interaction entre d'autres objets (collègues). Au lieu de communiquer directement, les objets interagissent via le médiateur.

Avantages de l'utilisation du médiateur :

Réduction du couplage : Les objets n'ont pas de références directes, ce qui réduit leur dépendance.
Simplification de la gestion : Les interactions sont centralisées, facilitant leur compréhension et modification.
Amélioration de la réutilisabilité : Les composants peuvent être réutilisés dans d'autres contextes.

Inconvénients :

Augmentation de la complexité du médiateur : Avec plus d'interactions, le médiateur peut devenir complexe.
Potentiel impact sur la performance : Toutes les interactions passent par un objet central.

Exemple simple d'implémentation :

// Interface du médiateur
public interface IMediator
{
    void SendMessage(string message, Colleague colleague);
}

// Classe de base pour les collègues
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);
}

// Médiateur concret
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);
        }
    }
}

// Collègues concrets
public class ConcreteColleague1 : Colleague
{
    public ConcreteColleague1(IMediator mediator) : base(mediator) { }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Message reçu par Collègue 1 : {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Message envoyé par Collègue 1 : {message}");
        mediator.SendMessage(message, this);
    }
}

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

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Message reçu par Collègue 2 : {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Message envoyé par Collègue 2 : {message}");
        mediator.SendMessage(message, this);
    }
}

// Exemple d'utilisation
// var mediator = new ConcreteMediator();
// var colleague1 = new ConcreteColleague1(mediator);
// var colleague2 = new ConcreteColleague2(mediator);
// mediator.Colleague1 = colleague1;
// mediator.Colleague2 = colleague2;
// colleague1.Send("Bonjour Collègue 2!");
// colleague2.Send("Bonjour Collègue 1!");

Souvent utilisé avec d'autres patrons, comme Observer, pour des systèmes de messagerie complexes. En .NET, il est fréquemment utilisé dans des bibliothèques de gestion de requêtes et commandes, comme MediatR.

Qu'est-ce qu'un médiateur dans le contexte de la programmation?