Ludo Programming

Pe măsură ce aplicațiile cresc, interacțiunea dintre componente devine din ce în ce mai dificil de gestionat. Clasele ajung să depindă unele de altele, logica de comunicare se împrăștie în tot codul, iar modificările mici produc efecte neprevăzute. Mediator Pattern apare exact pentru a rezolva această problemă.

Mediator Pattern este un design pattern comportamental care centralizează comunicarea dintre obiecte, reducând dependențele directe dintre ele și făcând sistemul mai ușor de extins și întreținut.

Ce este Mediator Pattern?

Mediator Pattern definește un obiect central – mediatorul – care gestionează comunicarea dintre mai multe componente. În loc ca obiectele să comunice direct între ele, ele trimit mesaje mediatorului, iar acesta decide ce acțiuni trebuie declanșate.

📌 Ideea-cheie:

„Obiectele nu mai vorbesc între ele, ci printr-un mediator.”

Astfel, fiecare componentă cunoaște doar mediatorul, nu și celelalte componente din sistem.

Problema pe care o rezolvă

Fără Mediator Pattern:

• Clasele sunt puternic cuplate

• Logica de comunicare este duplicată

• Codul devine greu de modificat

• Testarea este dificilă

Cu Mediator Pattern:

• Cuplarea este redusă

• Comunicarea este centralizată

• Codul devine mai clar și mai predictibil

• Componentele sunt mai ușor de reutilizat

Structura pattern-ului

Mediator Pattern este compus din:

1. Mediator – interfața de comunicare

2. ConcreteMediator – implementează logica de coordonare

3. Colleague – componentele care comunică prin mediator

4. ConcreteColleague – implementările concrete ale componentelor

Exemplu practic în C# (.NET)

Să luăm un exemplu simplu: o interfață cu butoane care trebuie să reacționeze unele la altele.

1️⃣ Interfața Mediator

public interface IMediator
{
    void Notify(object sender, string @event);
}

2️⃣ Mediatorul concret

public class DialogMediator : IMediator
{
    public Button SaveButton { get; set; }
    public Button CancelButton { get; set; }

    public void Notify(object sender, string @event)
    {
        if (@event == "SaveClicked")
        {
            CancelButton.Disable();
        }
        else if (@event == "CancelClicked")
        {
            SaveButton.Disable();
        }
    }
}

3️⃣ Componentele (Colleagues)

public class Button
{
    private readonly IMediator _mediator;
    public string Name { get; }

    public Button(IMediator mediator, string name)
    {
        _mediator = mediator;
        Name = name;
    }

    public void Click()
    {
        _mediator.Notify(this, $"{Name}Clicked");
    }

    public void Disable()
    {
        Console.WriteLine($"{Name} disabled");
    }
}

4️⃣ Utilizarea mediatorului

var mediator = new DialogMediator();

var saveButton = new Button(mediator, "Save");
var cancelButton = new Button(mediator, "Cancel");

mediator.SaveButton = saveButton;
mediator.CancelButton = cancelButton;

saveButton.Click();   // Cancel disabled
cancelButton.Click(); // Save disabled

✔ Butoanele nu știu nimic unul despre celălalt

✔ Toată logica este centralizată

✔ Codul este mai ușor de extins

Mediator Pattern în aplicații reale

Mediator Pattern este extrem de util în:

• Aplicații UI (WinForms, WPF, MAUI, Blazor)

• Sisteme de notificări

• Fluxuri de business

• Module care trebuie să colaboreze fără dependențe directe

• Sisteme event-driven

În .NET, pattern-ul este des întâlnit sub forma:

• Event Aggregator

• Message Bus

• MediatR (bibliotecă foarte populară)

Avantaje

✅ Reduce cuplarea dintre componente

✅ Centralizează logica de comunicare

✅ Cod mai ușor de întreținut

✅ Testare mai simplă

✅ Componente reutilizabile

Dezavantaje

⚠️ Mediatorul poate deveni prea complex

⚠️ Risc de „God Object” dacă nu este bine structurat

👉 Soluția: separarea clară a responsabilităților și mediatorii specializați.

Mediator Pattern vs Observer Pattern

• Observer: comunicare one-to-many, pasivă

• Mediator: coordonare activă, logică centralizată

În practică, cele două pattern-uri sunt adesea combinate.

Concluzie

Mediator Pattern este o soluție elegantă pentru sisteme complexe, în care obiectele trebuie să colaboreze fără a fi strâns legate între ele. Dacă simți că aplicația ta începe să semene cu un „păienjeniș” de dependențe, mediatorul este adesea răspunsul corect.