Was ist ein Mediator im Kontext der Programmierung…

Der Mediator ist ein Verhaltensmuster, das ein zentrales Objekt vorschlägt, um die Interaktion zwischen anderen Objekten (Kollegen) zu steuern. Statt dass Objekte direkt miteinander kommunizieren, interagieren sie über den Mediator.

Vorteile der Verwendung des Mediators:

Reduzierung der Kopplung: Objekte haben keine direkten Referenzen zueinander, was ihre Abhängigkeit verringert.
Vereinfachung der Steuerung: Die Interaktionen zwischen Objekten sind an einem Ort konzentriert, was das Verständnis und die Änderungen erleichtert.
Verbesserung der Wiederverwendbarkeit: Einzelne Komponenten können in anderen Kontexten wiederverwendet werden, da sie nicht stark an andere Komponenten gebunden sind.

Nachteile:

Erhöhung der Komplexität des Mediators: Mit zunehmender Anzahl an Interaktionen kann der Mediator komplex und schwer wartbar werden.
Mögliche Leistungseinbußen: Alle Interaktionen laufen über ein zentrales Objekt, was zusätzliche Kosten verursachen kann.

Beispiel für eine einfache Implementierung:

// Schnittstelle für den Mediator
public interface IMediator
{
    void SendMessage(string message, Colleague colleague);
}

// Basisklasse für Kollegen
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);
}

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

// Konkrete Kollegen
public class ConcreteColleague1 : Colleague
{
    public ConcreteColleague1(IMediator mediator) : base(mediator) { }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Nachricht empfangen von Kollege 1: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Nachricht gesendet von Kollege 1: {message}");
        mediator.SendMessage(message, this);
    }
}

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

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Nachricht empfangen von Kollege 2: {message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Nachricht gesendet von Kollege 2: {message}");
        mediator.SendMessage(message, this);
    }
}

// Beispiel für die Verwendung
// var mediator = new ConcreteMediator();
// var colleague1 = new ConcreteColleague1(mediator);
// var colleague2 = new ConcreteColleague2(mediator);
// mediator.Colleague1 = colleague1;
// mediator.Colleague2 = colleague2;
// colleague1.Send("Hallo Kollege 2!");
// colleague2.Send("Hallo Kollege 1!");

Wird häufig in Verbindung mit anderen Mustern wie Observer verwendet, um komplexere Nachrichtensysteme zu realisieren. Im .NET-Kontext findet es Anwendung in Bibliotheken für Anfragen und Befehle, wie MediatR.

Was ist ein Mediator im Kontext der Programmierung?