The document describes the mediator pattern for implementing a chatting application. It discusses problems with a direct communication approach between users and presents a solution using a ChatServer class as an intermediate mediator. The ChatServer stores user information and routes messages, allowing for two-way communication between online users and addressing issues like message delivery to offline users. Key aspects of the mediator pattern are highlighted, including how it enables more extensible communication across multiple machines compared to the observer pattern. Pseudocode is provided for the ChatServer, User classes and their collaboration through the mediator to enable basic chat functionality.

1. Class report
CLASS ASSIGNMENT- 3
MEDIATOR PATTERN
A CHATTING APPLICATION:
Introduction:
At first, we have to see what happens in this sort of chatting software, i.e. what
features we have to focus on.
Now, let’s see the criteria that we have to maintain in our program. One user
should be able to send message & receive message simultaneously in this sort
of chatting software, i.e. a two-way communication. Earlier, in the observer
pattern, we were concerned about one-way communication. So, let’s see
what we usually do in such cases.
There must be a User class. Let’s, see what may be there…..
Page 1 of 14

2. Class report
User:
Class User {
Name:
Description:
ID:
List <user> Friend list;
Methods like;
AddFriend (user U) {
Friend list. Add (U);
}
SendMessage (String msg ,User U)
{
Print (msg to U.name);
}
-may be present.
The main method should be as follows in such case:
Main () {
User U1 = new user (“U1”);
User U2 = new user (“U2”);
User U3 = new user (“U3”);
Page 2 of 14

3. Class report
U1.AddFriend (U2);
U2.AddFriend (U3);
U2.AddFriend (U1);
U3.AddFriend (U2);
……..
………
……….
U1.SendMessage (“Hi”, U2);
U2.SendMessage (“Hello”, U3);
………
………
………
}
Now, let’s see what are the problems that we may face if we solve in this way.
Problems:
Firstly,
If we print the following message inside the SendMessage() method
then it will only be seen on my screen, not on my friend’s which is actually not
our goal. So, the message should have not been there at all.
Page 3 of 14

4. Class report
SendMessage (String msg ,User U)
{
Print (msg to U.name);
}
So, the solution should be like this until now.
Solution:
SendMessage (msg.User U) {
U.ReceiveMessage (msg,this);
}
ReceiveMessage (msg,User U) {
Print (msg to U.name);
}
Now, another question may come in mind while giving this solution that why
we have used ‘this’? This is because we have to make him understand from
whom the message is coming as he is getting many more messages at the
same time from some other distinguished users.
Secondly;
What is the profit we have gained only by changing the position of
printing option inside the same user?
Page 4 of 14

5. Class report
Solution:
To be noted, here both U1 & U2 are instances of same class, i.e. User class. So,
the SendMessage option that we are using is for U1 & ReceiveMessage for U2.
And the message should be in the ReceiveMessage method in logical way.
Thirdly;
Once we added U2 as U1’s friend, which means U1 is also U2’s
friend. But, here we have done the later part again which is completely
redundant.
Main () {
User U1 = new user (“U1”);
User U2 = new user (“U2”);
User U3 = new user (“U3”);
U1.AddFriend (U2);
U2.AddFriend (U3);
U2.AddFriend (U1);
U3.AddFriend (U2);
……..
………
}
Solution:
Page 5 of 14

6. Class report
AddFriend (User U) {
Friend list. Add (U);
U.AddFriend (this);
}
But, point to be noted, this has become a recursive loop, i.e. a recursive
method. So, this can’t be the exact solution.
The exact solution for this certain problem be,
AddFriend (User U) {
………
………
Friend list. Add (U);
U. Friend list. Add (this);
}
Hence, there is no recursive loop now.
Fourthly,
If any user sends message to another user, the later one may be
offline/inactive, what will happen to the sent message?
Page 6 of 14

7. Class report
Solution:
SendMessage (msg, U)
{
///checking……….
If (U is not null)
U.ReceiveMessage (msg , this);
}
So, in this way we can ensure the receipt of the very message accordingly.
Fifthly,
The question comes; where will I get the user list? How will I know “A”
is a user & I can make him my friend?
Solution:
For solving the very problem, we have to make an intermediate step in
between the communication system that we have supported earlier.
That is, we have to make a chat server.
Page 7 of 14

8. Class report
User
U1
User... User
U2
Chat
Server
User User
U5 U3
User
U4
For instance;
Chat Server Class:
Chat Server {
User list; //global user list. When anyone signs up, added here.
Hashmap Friend list ;
SendMsg (msg, sender ID, receiver ID) {
Receiver= get User (receiver ID);
Receiver. ReceiveMsg (msg , sender ID);
}
Page 8 of 14

9. Class report
GetUser (User ID){
…………….
…………….
}
}
User Class:
User {
Name;
Chatserver server;
Friend list;
User (name, cs) {
………
………
Server=cs;
}
SendMsg (msg, receiver ID){
Server.SendMsg (msg, this.Id, receiver ID);
}
ReceiveMsg (msg, sender ID) {
Page 9 of 14

10. Class report
Print (“……….”);
}
Main() {
Chatserver cs = new Chat server ();
User U1 = new User (“User ID”, cs);
U1.SendMsg (msg, “user ID”);
………..
………..
………...}
So, whatever we got is;
Message History, User Status (offline/online) and Location of
message; all this information is found in server class.
To be noted;
This solution can easily work in multiple machines, which the
previous solution can’t. The previous solution can work in more than
one window, but confined in one machine. Hence, that was inextensible.
Now,
Answer to some possible questions is given below:
Page 10 of 14

11. Class report
 How is it a two-way communication system?
Point to be noted,
User has both SendMessage() & ReceiveMessage() method.
So, one can send & receive message at the same time. Hence, it is a two-way
communication system.
 How do we search friends?
Chat server =new Chat server ();
User ma = new User (“ma”, cs);
cs. SearchFriend(“Mahedi”); //return list that we are looking for.
Friend ID = list.getItem (s);
cs.AddFriend (“ma”, friend ID);
ma.SendMsg (“Hello”, friend ID);
Moreover,
What we can see is that user class only has SendMsg() &
ReceiveMSg() method. All other features that we have added & we are going
to add will be in the server class.
Hence, chat server acts here as an intermediate media & mediates among the
users. That’s why; this pattern is named as “Mediator Pattern”.
Though,
Both Observer Pattern & Mediator Pattern is concerned with
message passing, they have some distinct dissimilarities.
Page 11 of 14

12. Class report
 Observer pattern is for one-way communication & Mediator
pattern for two-way communication.
 Observer pattern has no intermediate layer whereas Mediator
pattern has so, i.e. chat server.
Thus,
The main code to solve the problem is shown below:
Main Code:
Chat Server Class:
Class ChatServer
{
User Receiver;
string s, r,m;
Hashtable hs;
Hashtable hs1;
public ChatServer()
{
hs = new Hashtable();
hs1 = new Hashtable();
}
public void AddName(string m, User u) {
hs1.Add(m,u);
}
public void SendMsg(string msg, string SenderID,string RecID) {
Page 12 of 14

13. Class report
s = SenderID;
r = RecID;
m = msg;
Receiver = (User)hs1[r];
Receiver.RecMsg(m,s);
}
public void AddFriend(string UserID, string FriendID) {
s = UserID;
r = FriendID;
hs.Add(s,r);
}
}
User Class:
Class User
{
ChatServer server;
string name;
public User(string name,ChatServer cs)
{
this.name = name;
server = cs;
}
Page 13 of 14

14. Class report
public void SendMsg(string m , string RecID) {
server.SendMsg(m,this.name,RecID);
}
public void RecMsg(string s, string SenderID) {
Console.WriteLine(" " + SenderID + " send " + s );
}
}
MainDemo Class:
class MainDemo
{
static void Main(string[] args)
{
ChatServer cs = new ChatServer();
User mahedi = new User("mahedi",cs);
cs.AddName("mahedi",mahedi);
cs.AddFriend("Mahedi","Mamun");
monir.SendMsg("hi", "Mamun");
Console.ReadKey();
}
}
}
…………………………………………………X…………………………………………………………..
Page 14 of 14