Mediator pattern concrete example

Design patterns serve as blueprints for solving recurring problems in software development, and among them, the Mediator Design Pattern shines in facilitating communication between disparate components. By promoting loose coupling and centralized control, the Mediator pattern streamlines complex systems and enhances maintainability.

Mediator Pattern

Belonging to the category of behavioral design patterns, the Mediator pattern focuses on defining an intermediary object that encapsulates how a set of objects interact. This intermediary, known as the mediator, promotes decoupling by facilitating indirect communication between objects.

Problem Statement

In complex systems such as air traffic control, managing communication between various components like aircraft, control towers, and ground staff poses a significant challenge. Direct communication between these entities can lead to tight coupling and hinder scalability and maintenance.

Solution with the Mediator Design Pattern

The Mediator pattern addresses this challenge by introducing a central mediator responsible for coordinating communication between different components. Instead of objects communicating directly with each other, they interact through the mediator, reducing dependencies and promoting flexibility.

Air Traffic Control System

Example of Implementation Let’s illustrate the Mediator pattern with a theoretical implementation tailored to an air traffic control system. We’ll start by defining the Mediator interface:

public interface IAirTraffic
{
    void RegisterAircraft(AirCraft aircraft);
    void SendMessage(string message, AirCraft sender);
}

We’ll define the Aircraft abstract class, representing objects that communicate through the mediator:

public abstract class AirCraft(IAirTraffi mediator)
{
    protected IAirTraffic mediator = mediator;

    public abstract void ReceiveMessage(string message);
}

Next, we’ll define the Aircraft class representing individual planes in the system:

public class Plane(string flightNumber, IAirTrafficControl mediator) : AirCraft(mediator)
{
    public string FlightNumber { get; private set; } = flightNumber;

    public void SendMessage(string message)
    {
        mediator.SendMessage(message, this);
    }

    public override void ReceiveMessage(string message)
    {
        Console.WriteLine($"Flight {FlightNumber} received: {message}");
    }
}

System Now, let’s implement the air traffic control system using the Mediator pattern:

public class AirTraffic : IAirTraffic
{
    private readonly List<AirCraft> aircrafts = [];

    public void RegisterAircraft(AirCraft aircraft)
    {
        aircrafts.Add(aircraft);
    }

    public void SendMessage(string message, AirCraft sender)
    {
        foreach (var aircraft in aircrafts)
        {
            if (aircraft != sender)
                aircraft.ReceiveMessage(message);
        }
    }
}

In this example, the AirTraffic class acts as the mediator, facilitating communication between individual aircraft. Each aircraft registers with the control system, and when a message is sent by one aircraft, the mediator relays it to all other aircraft.

Conclusion

The Mediator Design Pattern proves invaluable in managing communication between disparate components in complex systems like air traffic control. By introducing a central mediator, the pattern promotes loose coupling and enhances maintainability and scalability. Whether in air traffic control systems or other multi-entity environments, the Mediator pattern offers a robust solution for streamlined communication. We surely heard of the Mediatr Library, describes itself as a Simple mediator implementation in .NET.