Cos'è un mediatore nel contesto della programmazione?

Il mediatore è un pattern di progettazione comportamentale che propone un oggetto centralizzato per gestire l'interazione tra altri oggetti (colleghi). Invece di comunicare direttamente tra loro, gli oggetti interagiscono tramite il mediatore.

Vantaggi dell'uso del mediatore:

• Riduzione del coupling: Gli oggetti non hanno riferimenti diretti tra loro, riducendo la dipendenza.
• Semplificazione della gestione: Le interazioni tra oggetti sono concentrate in un unico luogo, facilitando comprensione e modifiche.
• Miglioramento della riutilizzabilità: Componenti singoli possono essere riutilizzati in altri contesti, poiché non sono fortemente legati ad altri componenti.

Svantaggi:

• Aumento della complessità del mediatore: Con l'aumentare delle interazioni, il mediatore può diventare complesso e difficile da mantenere.
• Potenziale impatto sulle prestazioni: Tutte le interazioni passano attraverso un oggetto centrale, potenzialmente introducendo overhead.

Esempio di implementazione semplice:

// Interfaccia per il mediatore
public interface IMediator
{
    void SendMessage(string message, Colleague colleague);
}

// Classe base per i colleghi
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);
}

// Mediatore concreto
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);
        }
    }
}

// Colleghi concreti
public class ConcreteColleague1 : Colleague
{
    public ConcreteColleague1(IMediator mediator) : base(mediator) { }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Messaggio ricevuto dal collega 1: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Messaggio inviato dal 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($"Messaggio ricevuto dal collega 2: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Messaggio inviato dal collega 2: {message}");
        mediator.SendMessage(message, this);
    }
}

// Esempio di utilizzo
// var mediator = new ConcreteMediator();
// var colleague1 = new ConcreteColleague1(mediator);
// var colleague2 = new ConcreteColleague2(mediator);
// mediator.Colleague1 = colleague1;
// mediator.Colleague2 = colleague2;
// colleague1.Send("Ciao collega 2!");
// colleague2.Send("Ciao collega 1!");

Viene spesso utilizzato in combinazione con altri pattern, come l'Observer, per implementare sistemi di scambio messaggi più complessi. Nel contesto .NET, è comunemente impiegato in librerie per lavorare con richieste e comandi, come MediatR.