Mediator pattern in C#

Hello, C# lovers! šŸ˜ 

In this post, I’m going to talk about the Mediator pattern and how you can use it in your C# projects. The Mediator pattern is a behavioral design pattern that helps you reduce the complexity of communication between multiple objects. It does this by introducing a mediator object that acts as a central hub for all the interactions between different objects. This way, the objects don’t need to know each other’s identities or methods, they just need to know the mediator. šŸ™Œ

Why use the Mediator pattern?

The Mediator pattern can help you achieve several benefits, such as:

  • Loose coupling: The objects are not directly dependent on each other, which makes them easier to reuse and test.
  • Single responsibility: The mediator object encapsulates the logic of communication, which makes it easier to modify and maintain.
  • Open/closed principle: You can add new objects or change their behavior without affecting the existing ones, as long as they conform to the mediator’s protocol.

How to implement the Mediator pattern in C#?

There are different ways to implement the Mediator pattern in C#, but one of the most common ones is using an abstract mediator class that defines an interface for communication, and a concrete mediator class that implements it. The mediator class usually has references to all the colleague objects that it mediates, and it can register or unregister them dynamically. The colleague objects are usually abstract classes or interfaces that define a common method for sending messages to the mediator. The concrete colleague classes implement this method and also have a method for receiving messages from the mediator.

Here is an example of how you can implement the Mediator pattern in C#:


// The abstract mediator class
public abstract class Mediator
{
    // The method for sending messages to colleagues
    public abstract void Send(string message, BtcExchange colleague);
}

// The concrete mediator class
public class ExchangeRateService : Mediator
{
    // A dictionary of registered colleagues
    private Dictionary<string, BtcExchange> subscribers = new Dictionary<string, BtcExchange>();

    // A method for registering colleagues
    public void Register(BtcExchange subscriber)
    {
        if (!subscribers.ContainsValue(subscriber))
        {
            subscribers[subscriber.Name] = subscriber;
        }
        subscriber.ExchangeRateService = this;
    }

    // A method for sending messages to colleagues
    public override void Send(string message, BtcExchange subscriber)
    {
        if (subscribers.ContainsValue(subscriber))
        {
            // Send the message to all colleagues except the sender
            foreach (var s in subscribers.Values)
            {
                if (s != subscriber)
                {
                    s.Receive(message);
                }
            }
        }
    }
}

// The abstract colleague class
public abstract class BtcExchange
{
    // A property for getting or setting the mediator
    public Mediator ExchangeRateService { get; set; }

    // A property for getting the colleague name
    public string Name { get; }

    // A constructor that takes a name as a parameter
    public BtcExchange(string name)
    {
        Name = name;
    }

    // A method for sending messages to the mediator
    public void Send(string message)
    {
        ExchangeRateService.Send(message, this);
    }

    // An abstract method for receiving messages from the mediator
    public abstract void Receive(string message);
}

// A concrete colleague class
public class Subscriber : BtcExchange
{
    // A constructor that takes a name as a parameter and calls the base constructor
    public Subscriber(string name) : base(name) { }

    // A method for receiving messages from the mediator
    public override void Receive(string message)
    {
        Console.WriteLine($"{Name} received: {message}");
    }
}

How to use the Mediator pattern in C#?

To use the Mediator pattern in C#, you need to create an instance of the concrete mediator class and register some instances of the concrete colleague classes with it. Then, you can use the Send method of any colleague object to send a message to all other colleagues through the mediator. Here is an example of how you can use the Mediator pattern in C#:


// Create an exchange rate service instance
var exchangeRateService = new ExchangeRateService();

// Create some subscriber instances
var binance = new Subscriber("Binance");
var coinbase = new Subscriber("Coinbase");
var kraken = new Subscriber("Kraken");

// Register them with the exchange rate service
exchangeRateService.Register(binance);
exchangeRateService.Register(coinbase);
exchangeRateService.Register(kraken);

// Send some messages
binance.Send("The current BTC/USD rate is 50,000");
coinbase.Send("The current BTC/EUR rate is 42,000");
kraken.Send("The current BTC/GBP rate is 36,000");

The output of this code is:


Coinbase received: The current BTC/USD rate is 50,000
Kraken received: The current BTC/USD rate is 50,000

Binance received: The current BTC/EUR rate is 42,000
Kraken received: The current BTC/EUR rate is 42,000

Binance received: The current BTC/GBP rate is 36,000
Coinbase received: The current BTC/GBP rate is 36,000

Where to learn more about the Mediator pattern in C#?

If you want to learn more about the Mediator pattern in C#, you can check out these resources:



I hope you enjoyed this post and learned something new about the Mediator pattern in C#. If you have any questions or feedback, feel free to leave a comment below. 


You can find the code examples here: source code


Happy coding! šŸ˜Š

Comments

Post a Comment

Popular posts from this blog

Which GOF patterns are good for C#?

Hello, C# fans! šŸ˜Š In this article, I will answer a common question that many C# developers have: which GOF patterns are good for C#? šŸ¤” GOF patterns are the 23 design patterns that were described in the book “ Design Patterns: Elements of Reusable Object-Oriented Software ” by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. They are also known as the Gang of Four (GoF) patterns. They are divided into three categories: creational, structural, and behavioral. šŸ“š These patterns provide solutions to common software design problems that you may encounter in your projects. They help you write code that is more reusable, flexible, maintainable, and elegant. šŸ˜ But not all GOF patterns are equally useful or applicable in C#. Some of them are more relevant and popular than others. Some are already supported by the language features or the .NET framework. Some of them may be outdated or replaced by newer patterns. šŸ˜® So, which GOF patterns are good for C#?  Creational patterns...
Read more

Angular on a regular SharePoint page (part 2)

Image
In my  previous article , we have added an empty angular element to the SharePoint page.  And now we are ready to move forward and add some functionality to our elements. Before we begin      First of all, let's create in SharePoint Announcements list with the name "Announcements" and add a couple of items with some text. We will access data in our list via the SharePoint REST API, calling "/_api/web/lists/getbytitle('Announcements')/Items" endpoint. Angular project      Now, open the angular elements project which we have created in the previous article in VS Code.      For convenience let's create an interface to work with our data model. Create the "data" folder wonder the "src/app" and create a new file named Announcement.ts.      Add this code to it: export interface Announcement { ID : number ; Title : string ; Body : string ; }      We will use the service to get the data from our list. ...
Read more

Chain of Responsibility pattern in C#

Hello, C# lovers! šŸ˜ Today I want to talk about a very useful design pattern called Chain of Responsibility. This pattern allows you to pass a request along a chain of handlers until one of them can handle it. This way, you can avoid coupling the sender of the request with the receiver, and you can dynamically compose the chain at runtime. Sounds cool, right? šŸ˜Ž Let’s see an example of how to implement this pattern in C#. Suppose you have a simple ATM machine that can dispense bills of 10, 20, and 50 dollars. You want to write a program that can handle any amount of money requested by the user, using the least number of bills possible. To do this, you can create an abstract class called Handler that defines an interface for handling the requests. It also has a reference to the next handler in the chain, and a method to set it. // The 'Handler' abstract class public abstract class Handler { protected Handler successor; public void SetSuccessor ( Handler successo...
Read more