Czym jest mediator w kontekście programowania?

Mediator to wzorzec projektowania behawioralnego, który proponuje scentralizowany obiekt do zarządzania interakcją między innymi obiektami (kolegami). Zamiast komunikować się bezpośrednio, obiekty komunikują się przez mediatora.

Zalety korzystania z mediatora:

• Zmniejszenie powiązań: Obiekty nie mają bezpośrednich odniesień do siebie, co zmniejsza ich zależność.
• Uproszczenie zarządzania: Interakcje między obiektami są skupione w jednym miejscu, co ułatwia ich zrozumienie i modyfikację.
• Poprawa ponownego użycia: Poszczególne komponenty można ponownie wykorzystywać w innych kontekstach, ponieważ nie są silnie powiązane z innymi komponentami systemu.

Wady:

• Zwiększenie złożoności mediatora: W miarę wzrostu liczby interakcji, mediator może stać się skomplikowany i trudny do utrzymania.
• Możliwe obniżenie wydajności: Wszystkie interakcje przechodzą przez centralny obiekt, co może generować dodatkowe koszty.

Przykład prostej implementacji:

// Interfejs dla mediatora
public interface IMediator
{
    void SendMessage(string message, Colleague colleague);
}

// Klasa bazowa dla kolegów
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);
}

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

// Koledzy konktetni
public class ConcreteColleague1 : Colleague
{
    public ConcreteColleague1(IMediator mediator) : base(mediator) { }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Wiadomość odebrana przez kolegę 1: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Wiadomość wysłana przez kolegę 1: {message}");
        mediator.SendMessage(message, this);
    }
}

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

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Wiadomość odebrana przez kolegę 2: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Wiadomość wysłana przez kolegę 2: {message}");
        mediator.SendMessage(message, this);
    }
}

// Przykład użycia
// var mediator = new ConcreteMediator();
// var colleague1 = new ConcreteColleague1(mediator);
// var colleague2 = new ConcreteColleague2(mediator);
// mediator.Colleague1 = colleague1;
// mediator.Colleague2 = colleague2;
// colleague1.Send("Cześć kolego 2!");
// colleague2.Send("Cześć kolego 1!");

Często używany w połączeniu z innymi wzorcami, takimi jak Observer, do implementacji bardziej złożonych systemów wymiany wiadomości. W kontekście .NET jest powszechnie stosowany w bibliotekach obsługi zapytań i poleceń, takich jak MediatR.