Real-Time Examples of Mediator Design Pattern in C#

Back to: Design Patterns in C# With Real-Time Examples

Real-Time Examples of the Mediator Design Pattern in C#

I will discuss the Real-Time Examples of the Mediator Design Pattern in C# in this article. Please read our previous article discussing the basic concepts of Mediator Design Patterns in C# with Examples. At the end of this article, you will understand the following Real-time Examples using the Mediator Design Pattern in C#.

Real-Time Example of Mediator Design Pattern in C#: Air Traffic Control (ATC)

Let’s consider a real-time scenario of an Air Traffic Control (ATC) system. In an airport, the control tower (the mediator) ensures that planes don’t land on the same runway simultaneously. Instead of planes communicating directly with each other, the control tower manages their landing times and runways. This scenario is a classic representation of the Mediator pattern. Let us see how we can implement the above example using the Interpreter Design Pattern in C#:

using System;
using System.Collections.Generic;
using System.Linq;

namespace MediatorDesignPattern
{
    //Mediator Interface
    public interface IControlTower
    {
        void RegisterRunway(Runway runway);
        bool RequestLandingPermission(Airplane airplane);
        void ReleaseRunway(Runway runway);
    }

    //Concrete Mediator (Control Tower)
    public class ControlTower : IControlTower
    {
        private List<Runway> _availableRunways = new List<Runway>();

        public void RegisterRunway(Runway runway)
        {
            _availableRunways.Add(runway);
        }

        public bool RequestLandingPermission(Airplane airplane)
        {
            if (_availableRunways.Any())
            {
                var assignedRunway = _availableRunways.First();
                _availableRunways.Remove(assignedRunway);
                airplane.AssignRunway(assignedRunway);
                return true;
            }
            return false; // No available runways
        }

        public void ReleaseRunway(Runway runway)
        {
            _availableRunways.Add(runway);
        }
    }

    //Colleague Classes(Airplane and Runway)
    public class Airplane
    {
        private readonly IControlTower _controlTower;
        public string FlightNumber { get; }

        public Airplane(string flightNumber, IControlTower controlTower)
        {
            FlightNumber = flightNumber;
            _controlTower = controlTower;
        }

        public void RequestLanding()
        {
            if (_controlTower.RequestLandingPermission(this))
            {
                Console.WriteLine($"Airplane {FlightNumber} is landing.");
            }
            else
            {
                Console.WriteLine($"Airplane {FlightNumber} is waiting for an available runway.");
            }
        }

        public void AssignRunway(Runway runway)
        {
            Console.WriteLine($"Airplane {FlightNumber} assigned to runway {runway.Id}.");
        }
    }

    public class Runway
    {
        public string Id { get; }

        public Runway(string id)
        {
            Id = id;
        }
    }
    
    // Testing the Mediator Design Pattern
    // Client Code
    public class Client
    {
        public static void Main()
        {
            IControlTower controlTower = new ControlTower();

            // Register two runways
            controlTower.RegisterRunway(new Runway("R1"));
            controlTower.RegisterRunway(new Runway("R2"));

            var airplane1 = new Airplane("FL123", controlTower);
            var airplane2 = new Airplane("FL456", controlTower);

            airplane1.RequestLanding();
            airplane2.RequestLanding();

            // Only one plane should land as we only have one runway. 
            // The other should wait for an available runway.

            Console.ReadKey();
        }
    }
}

In this example, the ControlTower (Mediator) manages which Airplane can land on which Runway. This ensures no direct communication between Airplane and Runway objects, minimizing potential collisions and optimizing safe landings. When you run the above code, you will get the following output.

Real-Time Example of Mediator Design Pattern in C#: Chat Room

A chatroom is a classic example of the Mediator pattern. Users send messages to the chatroom, and the chatroom broadcasts the message to all participants. Let us see how we can implement the above example using the Interpreter Design Pattern in C#:

using System;
using System.Collections.Generic;
using System.Linq;

namespace MediatorDesignPattern
{
    // Mediator
    public interface IChatRoom
    {
        void Register(Participant participant);
        void Send(string from, string to, string message);
    }

    public class ChatRoom : IChatRoom
    {
        private Dictionary<string, Participant> _participants = new Dictionary<string, Participant>();

        public void Register(Participant participant)
        {
            if (!_participants.ContainsValue(participant))
            {
                _participants[participant.Name] = participant;
                participant.ChatRoom = this;
            }
        }

        public void Send(string from, string to, string message)
        {
            Participant participant = _participants[to];
            if (participant != null)
            {
                participant.Receive(from, message);
            }
        }
    }

    // Colleague
    public class Participant
    {
        public string Name { get; private set; }
        public IChatRoom ChatRoom { get; set; }

        public Participant(string name)
        {
            Name = name;
        }

        public void Send(string to, string message)
        {
            ChatRoom.Send(Name, to, message);
        }

        public void Receive(string from, string message)
        {
            Console.WriteLine($"{from} to {Name}: '{message}'");
        }
    }

    // Testing the Mediator Design Pattern
    // Client Code
    public class Client
    {
        public static void Main()
        {
            var chatroom = new ChatRoom();

            var john = new Participant("John");
            var jane = new Participant("Jane");

            chatroom.Register(john);
            chatroom.Register(jane);

            john.Send("Jane", "Hey there!");
            jane.Send("John", "Hi John!");

            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output.

Real-Time Example of Mediator Design Pattern in C#: Smart Home System

Consider a smart home system where different components like lights, windows, curtains, and heaters can interact with each other through a central hub or controller. Let us see how we can implement the above example using the Interpreter Design Pattern in C#:

using System;
namespace MediatorDesignPattern
{
    // Mediator
    public interface IHomeController
    {
        void Notify(Component sender, string eventInfo);
    }

    public class HomeController : IHomeController
    {
        public void Notify(Component sender, string eventInfo)
        {
            if (sender is Window && eventInfo == "opened")
            {
                Console.WriteLine("Turning off heater...");
                Console.WriteLine("Turning off lights...");
            }
            // Add more interactions as needed...
        }
    }

    // Abstract Colleague
    public abstract class Component
    {
        protected IHomeController _controller;

        public Component(IHomeController controller)
        {
            _controller = controller;
        }
    }

    // Concrete Colleagues
    public class Window : Component
    {
        public Window(IHomeController controller) : base(controller) { }

        public void Open()
        {
            Console.WriteLine("Window opened.");
            _controller.Notify(this, "opened");
        }
    }

    public class Heater : Component
    {
        public Heater(IHomeController controller) : base(controller) { }

        public void TurnOn()
        {
            Console.WriteLine("Heater turned on.");
        }
    }

    // Testing the Mediator Design Pattern
    // Client Code
    public class Client
    {
        public static void Main()
        {
            // Usage
            var homeController = new HomeController();
            var window = new Window(homeController);
            var heater = new Heater(homeController);

            window.Open();  // This should notify the controller to turn off heater and lights

            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output.

Real-Time Example of Mediator Design Pattern in C#: UI Framework

Imagine a UI framework where components can notify other components of state changes. For instance, selecting an option in a dropdown might display or hide other related controls. Let us see how we can implement the above example using the Interpreter Design Pattern in C#:

using System;
namespace MediatorDesignPattern
{
    // Mediator
    public interface IUIController
    {
        void Notify(UIComponent sender, string eventInfo);
    }

    public class UIController : IUIController
    {
        public void Notify(UIComponent sender, string eventInfo)
        {
            if (sender is Dropdown && eventInfo == "option1_selected")
            {
                Console.WriteLine("Displaying additional text fields...");
            }
            // More interactions as needed...
        }
    }

    // Abstract Colleague
    public abstract class UIComponent
    {
        protected IUIController _controller;

        public UIComponent(IUIController controller)
        {
            _controller = controller;
        }
    }

    // Concrete Colleagues
    public class Dropdown : UIComponent
    {
        public Dropdown(IUIController controller) : base(controller) { }

        public void SelectOption(string option)
        {
            Console.WriteLine($"Option {option} selected.");
            _controller.Notify(this, $"{option}_selected");
        }
    }

    public class TextField : UIComponent
    {
        public TextField(IUIController controller) : base(controller) { }

        public void Display()
        {
            Console.WriteLine("Text field displayed.");
        }
    }

    // Testing the Mediator Design Pattern
    // Client Code
    public class Client
    {
        public static void Main()
        {
            // Usage
            var uiController = new UIController();
            var dropdown = new Dropdown(uiController);
            var textField = new TextField(uiController);

            dropdown.SelectOption("option1");  // This should notify the UI controller to display additional text fields

            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output.

Real-Time Example of Mediator Design Pattern in C#: Taxi Dispatch System

In a taxi dispatch system, drivers and passengers can communicate indirectly through the central system (Mediator). Passengers request rides, and available drivers get notified. Once a driver accepts, the passenger is notified. Let us see how we can implement the above example using the Interpreter Design Pattern in C#:

using System;
using System.Collections.Generic;
using System.Linq;

namespace MediatorDesignPattern
{
    // Mediator
    public interface IDispatchSystem
    {
        void RegisterDriver(Driver driver);
        void RequestRide(Passenger passenger, string destination);
        void RideAccepted(Driver driver, Passenger passenger);
    }

    public class TaxiDispatch : IDispatchSystem
    {
        private List<Driver> _availableDrivers = new List<Driver>();
        private Dictionary<Passenger, string> _waitingPassengers = new Dictionary<Passenger, string>();

        public void RegisterDriver(Driver driver)
        {
            if (!_availableDrivers.Contains(driver))
            {
                _availableDrivers.Add(driver);
                driver.SetMediator(this);
            }
        }

        public void RequestRide(Passenger passenger, string destination)
        {
            if (_availableDrivers.Any())
            {
                var driver = _availableDrivers.First();
                _waitingPassengers[passenger] = destination;
                driver.NotifyRideRequest(passenger, destination);
            }
        }

        public void RideAccepted(Driver driver, Passenger passenger)
        {
            if (_waitingPassengers.ContainsKey(passenger))
            {
                _availableDrivers.Remove(driver);
                _waitingPassengers.Remove(passenger);
                passenger.NotifyRideAccepted(driver);
            }
        }
    }

    // Colleagues
    public class Driver
    {
        public string Name { get; }
        private IDispatchSystem _mediator;

        public Driver(string name)
        {
            Name = name;
        }

        public void SetMediator(IDispatchSystem mediator)
        {
            _mediator = mediator;
        }

        public void NotifyRideRequest(Passenger passenger, string destination)
        {
            Console.WriteLine($"{Name} received ride request from {passenger.Name} to {destination}.");
            // When the driver accepts the ride
            _mediator.RideAccepted(this, passenger);
        }
    }

    public class Passenger
    {
        public string Name { get; }
        private IDispatchSystem _mediator;

        public Passenger(string name, IDispatchSystem mediator)
        {
            Name = name;
            _mediator = mediator;
        }

        public void RequestRide(string destination)
        {
            _mediator.RequestRide(this, destination);
        }

        public void NotifyRideAccepted(Driver driver)
        {
            Console.WriteLine($"{Name}'s ride request has been accepted by {driver.Name}.");
        }
    }

    // Testing the Mediator Design Pattern
    // Client Code
    public class Client
    {
        public static void Main()
        {
            var dispatch = new TaxiDispatch();

            var driverJohn = new Driver("John");
            dispatch.RegisterDriver(driverJohn);

            var passengerAlice = new Passenger("Alice", dispatch);
            passengerAlice.RequestRide("Central Park");

            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output.

Real-Time Example of Mediator Design Pattern in C#: Stock Exchange

In a stock exchange system, traders don’t buy and sell shares directly to each other. They place orders, and a centralized system (the Mediator) matches buy and sell orders. Let us see how we can implement the above example using the Interpreter Design Pattern in C#:

using System;
using System.Collections.Generic;
using System.Linq;

namespace MediatorDesignPattern
{
    // Mediator
    public interface IStockExchange
    {
        void PlaceOrder(Trader trader, string stockSymbol, int quantity, OrderType orderType);
    }

    public class StockExchange : IStockExchange
    {
        // Simplified order-matching logic for illustration purposes
        private Dictionary<string, List<Order>> _buyOrders = new Dictionary<string, List<Order>>();
        private Dictionary<string, List<Order>> _sellOrders = new Dictionary<string, List<Order>>();

        public void PlaceOrder(Trader trader, string stockSymbol, int quantity, OrderType orderType)
        {
            var order = new Order(trader, stockSymbol, quantity, orderType);

            if (orderType == OrderType.Buy && _sellOrders.ContainsKey(stockSymbol) && _sellOrders[stockSymbol].Any())
            {
                var matchingOrder = _sellOrders[stockSymbol].First();
                ExecuteTrade(order, matchingOrder);
                _sellOrders[stockSymbol].Remove(matchingOrder);
            }
            else if (orderType == OrderType.Sell && _buyOrders.ContainsKey(stockSymbol) && _buyOrders[stockSymbol].Any())
            {
                var matchingOrder = _buyOrders[stockSymbol].First();
                ExecuteTrade(order, matchingOrder);
                _buyOrders[stockSymbol].Remove(matchingOrder);
            }
            else
            {
                if (orderType == OrderType.Buy)
                {
                    if (!_buyOrders.ContainsKey(stockSymbol)) _buyOrders[stockSymbol] = new List<Order>();
                    _buyOrders[stockSymbol].Add(order);
                }
                else
                {
                    if (!_sellOrders.ContainsKey(stockSymbol)) _sellOrders[stockSymbol] = new List<Order>();
                    _sellOrders[stockSymbol].Add(order);
                }
            }
        }

        private void ExecuteTrade(Order buyOrder, Order sellOrder)
        {
            Console.WriteLine($"Trade executed: {buyOrder.StockSymbol} - {buyOrder.Quantity} shares @ market price");
        }
    }

    public enum OrderType { Buy, Sell }

    public class Order
    {
        public Trader Trader { get; }
        public string StockSymbol { get; }
        public int Quantity { get; }
        public OrderType OrderType { get; }

        public Order(Trader trader, string stockSymbol, int quantity, OrderType orderType)
        {
            Trader = trader;
            StockSymbol = stockSymbol;
            Quantity = quantity;
            OrderType = orderType;
        }
    }

    public class Trader
    {
        private IStockExchange _mediator;
        public string Name { get; }

        public Trader(string name, IStockExchange mediator)
        {
            Name = name;
            _mediator = mediator;
        }

        public void PlaceOrder(string stockSymbol, int quantity, OrderType orderType)
        {
            _mediator.PlaceOrder(this, stockSymbol, quantity, orderType);
        }
    }

    // Testing the Mediator Design Pattern
    // Client Code
    public class Client
    {
        public static void Main()
        {
            var stockExchange = new StockExchange();

            var traderBob = new Trader("Bob", stockExchange);
            var traderAlice = new Trader("Alice", stockExchange);

            traderBob.PlaceOrder("AAPL", 100, OrderType.Buy);
            traderAlice.PlaceOrder("AAPL", 100, OrderType.Sell);

            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output.

Trade executed: AAPL – 100 shares @ market price

Real-Time Example of Mediator Design Pattern in C#: Online Auction System

Consider an online auction system where bidders can bid on an item. All the communication between bidders and the auctioneer will happen through the auction system (Mediator). Let us see how we can implement the above example using the Interpreter Design Pattern in C#:

using System;
using System.Collections.Generic;
using System.Linq;

namespace MediatorDesignPattern
{
    // Mediator
    public interface IAuctionMediator
    {
        void PlaceBid(Bidder bidder, decimal amount);
        void RegisterBidder(Bidder bidder);
        void StartAuction(decimal startPrice);
        void CloseAuction();
    }

    public class Auction : IAuctionMediator
    {
        private decimal _currentPrice;
        private Bidder _highestBidder;
        private List<Bidder> _bidders = new List<Bidder>();

        public void RegisterBidder(Bidder bidder)
        {
            _bidders.Add(bidder);
            bidder.JoinAuction(this);
        }

        public void StartAuction(decimal startPrice)
        {
            _currentPrice = startPrice;
            Console.WriteLine($"Auction started at price: {startPrice}");
        }

        public void PlaceBid(Bidder bidder, decimal amount)
        {
            if (amount > _currentPrice)
            {
                _currentPrice = amount;
                _highestBidder = bidder;
                Console.WriteLine($"{bidder.Name} is the highest bidder with {amount}!");
            }
            else
            {
                Console.WriteLine($"{bidder.Name}'s bid of {amount} is below the current highest bid.");
            }
        }

        public void CloseAuction()
        {
            Console.WriteLine($"Auction closed! {_highestBidder.Name} wins with a bid of {_currentPrice}!");
        }
    }

    // Colleague
    public class Bidder
    {
        public string Name { get; private set; }
        private IAuctionMediator _auction;

        public Bidder(string name)
        {
            Name = name;
        }

        public void JoinAuction(IAuctionMediator auction)
        {
            _auction = auction;
        }

        public void Bid(decimal amount)
        {
            _auction.PlaceBid(this, amount);
        }
    }

    // Testing the Mediator Design Pattern
    // Client Code
    public class Client
    {
        public static void Main()
        {
            var auction = new Auction();

            var bidderJohn = new Bidder("John");
            var bidderJane = new Bidder("Jane");

            auction.RegisterBidder(bidderJohn);
            auction.RegisterBidder(bidderJane);

            auction.StartAuction(100);
            bidderJohn.Bid(120);
            bidderJane.Bid(130);
            bidderJohn.Bid(140);

            auction.CloseAuction();

            Console.ReadKey();
        }
    }
}

In this example:

• Auction (Mediator): Represents the auction system where bidders can place bids. It keeps track of the highest bid and the bidder with the highest bid.
• Bidder (Colleague): Represents an individual or entity who can place a bid on an item. They communicate with the auction system to place their bids.

The Mediator pattern, in this case, ensures that bidders don’t need to know about each other, and all interactions are centralized in the Auction mediator. This makes adding more features or changing bidding rules easier in the future since changes will mostly be in the Auction class. When you run the above code, you will get the following output.

Real-Time Example of Mediator Design Pattern in C#: Job Portal

Employers can post job vacancies in a job portal, and job seekers can apply. The portal acts as a mediator, facilitating the interaction between job seekers and employers. Let us see how we can implement the above example using the Interpreter Design Pattern in C#:

using System;
using System.Collections.Generic;

namespace MediatorDesignPattern
{
    // Mediator
    public interface IJobPortal
    {
        void PostJob(Employer employer, string jobDescription);
        void Apply(JobSeeker seeker, string jobDescription);
    }

    public class JobPortal : IJobPortal
    {
        private Dictionary<string, Employer> _jobs = new Dictionary<string, Employer>();

        public void PostJob(Employer employer, string jobDescription)
        {
            _jobs[jobDescription] = employer;
            Console.WriteLine($"{employer.Name} posted a job: {jobDescription}");
        }

        public void Apply(JobSeeker seeker, string jobDescription)
        {
            if (_jobs.TryGetValue(jobDescription, out Employer employer))
            {
                Console.WriteLine($"{seeker.Name} applied for {employer.Name}'s job: {jobDescription}");
                employer.ReceiveApplication(seeker, jobDescription);
            }
        }
    }

    // Colleague
    public class Employer
    {
        public string Name { get; private set; }
        private IJobPortal _portal;

        public Employer(string name, IJobPortal portal)
        {
            Name = name;
            _portal = portal;
        }

        public void PostJob(string description)
        {
            _portal.PostJob(this, description);
        }

        public void ReceiveApplication(JobSeeker seeker, string jobDescription)
        {
            Console.WriteLine($"Received an application from {seeker.Name} for job: {jobDescription}");
        }
    }

    public class JobSeeker
    {
        public string Name { get; private set; }
        private IJobPortal _portal;

        public JobSeeker(string name, IJobPortal portal)
        {
            Name = name;
            _portal = portal;
        }

        public void Apply(string jobDescription)
        {
            _portal.Apply(this, jobDescription);
        }
    }

    // Testing the Mediator Design Pattern
    // Client Code
    public class Client
    {
        public static void Main()
        {
            // Usage
            var jobPortal = new JobPortal();

            var employer = new Employer("TechCorp", jobPortal);
            var jobSeeker = new JobSeeker("John", jobPortal);

            employer.PostJob("Software Engineer");
            jobSeeker.Apply("Software Engineer");

            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output.

Advantages and Disadvantages of Mediator Design Pattern in C#

The Mediator design pattern offers a mechanism to encapsulate and centralize interactions between different classes. Like any design pattern, the Mediator pattern has both advantages and disadvantages. Here are the pros and cons when applied in C# or any object-oriented language:

Advantages of Mediator Design Pattern in C#:

• Reduced Coupling: One of the main benefits of the Mediator pattern is that it reduces the coupling between classes. Instead of classes communicating directly with each other, they only communicate with the mediator, who knows and directs the communication.
• Increased Maintainability: By centralizing external communications, the system becomes more maintainable. Changing interactions between objects can often be done by changing the mediator without modifying individual classes.
• Flexibility in Object Interactions: The mediator pattern allows you to encapsulate and change the interactions between objects in a single place. This provides flexibility that would be hard to achieve if the objects were tightly coupled.
• Simplified Interface: When there are many interactions between objects, understanding and managing all the dependencies can become challenging. Using a mediator makes the interactions centralized and easier to understand and manage.
• Easier Testing: With reduced coupling, unit testing becomes easier. Individual classes can be tested in isolation with a mock mediator, making it straightforward to test different scenarios.

Disadvantages of Mediator Design Pattern in C#:

• Mediator Complexity: One of the primary concerns with the Mediator pattern is that the mediator itself can become overly complex. It might become a monolithic class that becomes a bottleneck, sometimes called a “God Object.”
• Performance Concerns: All communications pass through the mediator, which might introduce a performance overhead, especially if the mediator’s logic is complex or there’s a large volume of communication.
• Indirect Communication: While the mediator pattern simplifies interactions, it can also make the system harder to grasp for newcomers because the direct communication path isn’t always evident.
• Overhead of Indirection: If not carefully implemented, there can be unnecessary indirection layers, making debugging more challenging.
• Potential for Misuse: When direct communication between objects is more straightforward and intuitive, introducing a mediator might overcomplicate the design.

In conclusion, like any design pattern, the Mediator pattern should be used judiciously, considering the application’s specific needs. It’s vital to weigh its benefits against the potential drawbacks in any given scenario to make an informed decision.

When to use Mediator Design Pattern in Real-Time Applications?

The Mediator design pattern is a behavioral pattern that allows for the decoupling of objects by making them communicate indirectly through a mediator object. This pattern is valuable when you want to simplify and modularize interactions between sets of objects. Here are some scenarios in real-time applications where the Mediator pattern can be beneficial:

• Complex User Interfaces: When a user interface has numerous components that need to interact, such as buttons enabling/disabling based on certain criteria, input fields affecting the state of other fields, or various UI elements requiring synchronization. An example might be a registration form where the input in one field determines the state or content of another. Instead of each field communicating directly with all others, a mediator can manage these relationships.
• Chat Rooms: In chat applications, where each participant should be able to send messages to others. Instead of each participant sending messages directly to every other, a central chat room (mediator) handles message distribution.
• Air Traffic Control: The control tower (mediator) ensures that planes are landing or taking off without conflicts, rather than each plane communicating with all the others.
• Workflow Engines: In complex systems where various processes depend on each other, a mediator can ensure the correct sequence and conditionally execute certain processes based on the outcomes of others.
• Event Broker Systems: In systems with multiple services or components reacting to events, a centralized event broker (mediator) can handle and distribute these events to registered subscribers.
• Networking: In protocols where multiple devices need to communicate but should not do so directly, a central mediator can facilitate and control this communication.
• Game Lobby or Multiplayer Gaming: Players might need to join a room or lobby in multiplayer games. The game lobby is a mediator, managing players, game stats, and messages between players.
• Decoupling Modules in Large Systems: When building modular systems, especially in microservices architecture, it’s essential to decouple modules so that a change in one doesn’t have a cascading effect on others. A mediator can help by being the point of communication between modules.

When not to use the Mediator pattern?

Overuse of the Mediator pattern can lead to problems. If the mediator starts to get too many responsibilities, it can become a monolithic object that is hard to maintain, known as the “God Object” anti-pattern. It’s essential to strike a balance and avoid dumping too much logic into the mediator.

If interactions are relatively simple or direct communication is more intuitive and maintainable, then introducing a mediator might add unnecessary complexity.

In the next article, I will discuss the Memento Design Pattern in C# with Examples. Here, in this article, I try to explain Real-Time Examples of Mediator Design Patterns in C#. I hope you enjoy this article.