Verwendung des Mediator-Entwurfsmusters in C #

Entwurfsmuster werden verwendet, um häufig auftretende Entwurfsprobleme zu lösen und die Komplexität in unserem Code zu verringern. Das Mediatormuster ist ein Verhaltensentwurfsmuster, das die lose Kopplung zwischen Objekten fördert und dabei hilft, den Code für die Kommunikation zwischen Objekten zu organisieren.

Dieser Artikel enthält eine Diskussion des Mediator-Entwurfsmusters und dessen Implementierung mit C #.

Was ist das Mediator-Designmuster? 

Stellen Sie sich eine Anwendung vor, in der viele Objekte miteinander kommunizieren. Das Mediator-Entwurfsmuster ist nützlich, wenn die Anzahl der Objekte so groß wird, dass es schwierig wird, die Verweise auf die Objekte beizubehalten. Der Mediator ist im Wesentlichen ein Objekt, das zusammenfasst, wie ein oder mehrere Objekte miteinander interagieren. Das Mediator-Entwurfsmuster steuert, wie diese Objekte kommunizieren, und hilft, die Anzahl der Abhängigkeiten zwischen ihnen zu verringern, die Sie verwalten müssen.

Im Mediator-Entwurfsmuster kommunizieren die Objekte nicht direkt miteinander, sondern über den Mediator. Wenn ein Objekt mit einem anderen Objekt oder einer Reihe von Objekten kommunizieren muss, überträgt es die Nachricht an den Mediator. Der Mediator überträgt dann die Nachricht in einer für ihn verständlichen Form an jedes Empfängerobjekt.

Durch das Eliminieren der direkten Kommunikation zwischen Objekten fördert das Mediator-Entwurfsmuster eine lose Kopplung. Der andere Vorteil der Verwendung des Mediator-Entwurfsmusters besteht darin, dass es die Lesbarkeit und Wartbarkeit des Codes verbessert. Hier ist die offizielle Definition des Mediatormusters für die Viererbande:

Definieren Sie ein Objekt, das die Interaktion einer Gruppe von Objekten zusammenfasst. Mediator fördert die lose Kopplung, indem verhindert wird, dass Objekte explizit aufeinander verweisen, und Sie können ihre Interaktion unabhängig voneinander variieren.

Beachten Sie, dass sich das Mediator-Designmuster vom Fassaden-Designmuster unterscheidet. Das Mediatormuster erleichtert die Interaktion einer Reihe von Objekten, während das Fassadenmuster lediglich eine einheitliche Schnittstelle zu einer Reihe von Schnittstellen in der Anwendung bietet. Somit ist das Mediatormuster ein Verhaltensmuster, das sich mit dem Objektverhalten befasst, das Fassadenmuster ist ein Strukturmuster, das sich mit der Objektzusammensetzung befasst.

Implementieren des Mediator-Entwurfsmusters in C #

Aber genug von den Konzepten - lassen Sie uns in einen Code einsteigen. Die Teilnehmer an diesem Entwurf sind der Mediator, der konkrete Mediator und ein oder mehrere Teilnehmertypen. Während der Mediator für die Definition der Schnittstelle für die Kommunikation mit den Teilnehmern verantwortlich ist, implementiert der konkrete Mediator, wie der Name schon sagt, die Mediator-Schnittstelle und verfügt über Kenntnisse der Teilnehmer. Beachten Sie, dass der Teilnehmertyp manchmal als Kollege bezeichnet wird. In einigen Implementierungen gibt es also Kollegen und konkrete Kollegentypen.

Beziehen Sie sich nun auf die folgende Schnittstelle. Dies ist die Schnittstelle für den Mediator, den wir in diesem Beispiel verwenden werden.

öffentliche Schnittstelle Imediator

    {

        void AddParticipant (IParticipant-Teilnehmer);

        void BroadcastMessage (String-Nachricht, IParticipant-Absender);

    }}

Beachten Sie, dass diese Schnittstelle die Deklaration von zwei Methoden enthält, AddParticipant und  BroadcastMessage. Während Ersteres verwendet wird, um Teilnehmer zu einer Liste von Teilnehmern hinzuzufügen, die von der  ConcreteMediator Klasse verwaltet werden (siehe unten), wird Letzteres verwendet, um Nachrichten an die Liste der Teilnehmer zu senden.

Hier ist die  ConcreteMediator Klasse. Es implementiert die  IMediator Schnittstelle. Ich überlasse die Implementierung der  BroadcastMessage Methode dem Ausfüllen.

öffentliche Klasse ConcreteMediator: Imediator

    {

        Liste Teilnehmer = neue Liste ();

        public void AddParticipant (IParticipant-Teilnehmer)

        {

            Teilnehmer.Add (Teilnehmer);

        }}

        public void BroadcastMessage (String-Nachricht, IParticipant-Absender)

        {

            // Schreiben Sie hier Code, um die Nachricht an die Teilnehmer zu senden

        }}

    }}

Die IParticipantSchnittstelle enthält die Deklaration der  SendMessage Methode.

öffentliche Schnittstelle Teilnehmer

    {

        void SendMessage (String-Nachricht);

    }}

Hier ist ein Beispiel für die konkreten Teilnehmerklassen. Beachten Sie, dass diese Klassen die IParticipant Schnittstelle implementieren  .

öffentliche Klasse ConcreteParticipant1: Iparticipant

    {

        geschützter IMediator Mediator;

        public ConcreteParticipant1 (IMediator-Mediator)

        {

            this.mediator = Mediator;

        }}

        public void SendMessage (String-Nachricht)

        {

            mediator.SendMessage (message, this);

        }}

    }}

    öffentliche Klasse ConcreteParticipant2: Iparticipant

    {

        geschützter IMediator Mediator;

        public ConcreteParticipant2 (IMediator-Mediator)

        {

            this.mediator = Vermittler;

        }}

        public void SendMessage (String-Nachricht)

        {

            mediator.SendMessage (message, this);

        }}

    }}

Und das ist es! Das folgende Codefragment zeigt, wie Sie alle bisher erstellten Typen verwenden können.

statische Leere Main (string [] args)

    {

        IMediator mediator = neuer ConcreteMediator ();

        IParticipant Teilnehmer1 = neuer ConcreteParticipant1 (Mediator);

        IParticipant Participant2 = neuer ConcreteParticipant2 (Mediator);

        mediator.AddParticipant (Teilnehmer1);

        mediator.AddParticipant (Teilnehmer2);

        Teilnehmer1.SendMessage ("Dies ist der erste Teilnehmer");

        Teilnehmer2.SendMessage ("Dies ist der zweite Teilnehmer");

        Console.ReadLine ();

    }}

Das Mediator-Entwurfsmuster ist ein Verhaltensmuster, das eine lose Kopplung fördert, indem es die Kommunikation zwischen unterschiedlichen Objekten vermittelt. Da der Mediator alle Interaktionen zwischen Objekten erleichtert, können diese Objekte nach Belieben geändert werden. Vor allem müssen sie keine Kenntnisse voneinander haben. Auf diese Weise können Sie mit dem Mediator-Muster gut strukturierten, wartbaren und leicht testbaren Code schreiben.