Breaking News: Grepper is joining You.com. Read the official announcement!

mediator pattern in design pattern

Amjad Saeed answered on July 30, 2023 Popularity 9/10 Helpfulness 1/10

answer mediator pattern in design pattern

related Mediator pattern

mediator pattern in design pattern

Comment

5. Mediator Pattern:
The Mediator pattern defines an object that encapsulates how a set of objects interact. It promotes loose coupling by keeping objects from referring to each other explicitly.

Example in React:
Suppose you have multiple components in your React application, and you want to create a mediator to manage communication between them.

import React, { useState } from 'react';

// Mediator
const Mediator = () => {
  const [state, setState] = useState('');

  const sendMessage = (message) => {
    setState(message);
  };

  return (
    <div>
      <p>Mediator State: {state}</p>
      <ComponentA sendMessage={sendMessage} />
      <ComponentB sendMessage={sendMessage} />
    </div>
  );
};

// Components
const ComponentA = ({ sendMessage }) => {
  const handleClick = () => {
    sendMessage('Hello from Component A');
  };

  return (
    <button onClick={handleClick}>Send Message from A</button>
  );
};

const ComponentB = ({ sendMessage }) => {
  const handleClick = () => {
    sendMessage('Hello from Component B');
  };

  return (
    <button onClick={handleClick}>Send Message from B</button>
  );
};

const MediatorPatternExample = () => {
  return (
    <div>
      <Mediator />
    </div>
  );
};

export default MediatorPatternExample;

Popularity 9/10 Helpfulness 1/10 Language javascript

Source: Grepper

Tags: javascript mediator

Link to this answer
Share Copy Link

Contributed on Sep 14 2023

Amjad Saeed

0 Answers Avg Quality 2/10

Closely Related Answers

Mediator pattern

Comment

using System;
using System.Collections.Generic;

// Mediator interface
public interface IChatRoom
{
    void SendMessage(string message, string senderName);
    void RegisterUser(User user);
}

// Concrete mediator class (Chat Room)
public class ChatRoom : IChatRoom
{
    private readonly Dictionary<string, User> users = new Dictionary<string, User>();

    public void SendMessage(string message, string senderName)
    {
        if (users.TryGetValue(senderName, out User sender))
        {
            foreach (var user in users.Values)
            {
                if (user != sender)
                {
                    user.ReceiveMessage(message, senderName);
                }
            }
        }
    }

    public void RegisterUser(User user)
    {
        if (!users.ContainsKey(user.Name))
        {
            users.Add(user.Name, user);
        }
    }
}

// Colleague interface
public abstract class User
{
    protected IChatRoom chatRoom;
    public string Name { get; private set; }

    public User(string name, IChatRoom chatRoom)
    {
        Name = name;
        this.chatRoom = chatRoom;
        chatRoom.RegisterUser(this);
    }

    public abstract void Send(string message);
    public abstract void ReceiveMessage(string message, string senderName);
}

// Concrete colleague class (Regular User)
public class RegularUser : User
{
    public RegularUser(string name, IChatRoom chatRoom) : base(name, chatRoom)
    {
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Regular User '{Name}' sends: {message}");
        chatRoom.SendMessage(message, Name);
    }

    public override void ReceiveMessage(string message, string senderName)
    {
        Console.WriteLine($"Regular User '{Name}' received from '{senderName}': {message}");
    }
}

// Concrete colleague class (Premium User)
public class PremiumUser : User
{
    public PremiumUser(string name, IChatRoom chatRoom) : base(name, chatRoom)
    {
    }

    public override void Send(string message)
    {
        Console.WriteLine($"Premium User '{Name}' sends: {message}");
        chatRoom.SendMessage(message, Name);
    }

    public override void ReceiveMessage(string message, string senderName)
    {
        Console.WriteLine($"Premium User '{Name}' received from '{senderName}': {message}");
    }
}

class Program
{
    static void Main()
    {
        IChatRoom chatRoom = new ChatRoom();

        // Create users and register them with the chat room (mediator)
        User john = new RegularUser("John", chatRoom);
        User anna = new PremiumUser("Anna", chatRoom);
        User mike = new RegularUser("Mike", chatRoom);

        // Send messages
        john.Send("Hello, everyone!");
        anna.Send("Hi, John!");
        mike.Send("Hey, guys!");

        /*
         * Sample Output:
         * Regular User 'John' sends: Hello, everyone!
         * Regular User 'Mike' received from 'John': Hello, everyone!
         * Premium User 'Anna' sends: Hi, John!
         * Regular User 'John' received from 'Anna': Hi, John!
         * Regular User 'Mike' sends: Hey, guys!
         * Regular User 'John' received from 'Mike': Hey, guys!
         * Premium User 'Anna' received from 'Mike': Hey, guys!
         */
    }
}

Popularity 9/10 Helpfulness 1/10 Language csharp

Source: chat.openai.com

Tags: c# c

Link to this answer
Share Copy Link

Contributed on Jul 30 2023

mahnaz foroutan

0 Answers Avg Quality 2/10

mediator pattern in design pattern

Contents

More Related Answers

mediator pattern in design pattern

Closely Related Answers

Mediator pattern

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.