Applying Behavioral Patterns in Real-World Scenarios

We are advancing through our journey of building various real-world applications. We have explored the Command, Observer, and Strategy patterns in the previous units. In this unit, we will integrate all three behavioral patterns into different scenarios to solve real-world problems.

In this unit, we will use different combinations of behavioral patterns to solve real-world problems. Let's have a quick recap on what each pattern does:

• Command Pattern: Encapsulates a request as an object, allowing clients to parameterize and queue requests.
• Observer Pattern: Defines a one-to-many dependency between objects, ensuring that when one object changes state, all its dependents are notified and updated automatically.
• Strategy Pattern: Defines a family of algorithms, encapsulates each one and makes them interchangeable. Clients can choose the algorithm to use at runtime.

Here is one scenario of using Command and Observer patterns together to build a chat application.

First, we define a base ICommand interface with an Execute method. This interface will serve as the blueprint for all command objects.

// Command Pattern Interface for Chat Application
interface ICommand {
    // Method to execute the command
    void Execute();
}

We will also define a User class where that can receive and print messages. This class represents the observer in the Observer pattern.

class User {
    private string name;

    // Constructor to initialize the user's name
    public User(string name) {
        this.name = name;
    }

    // Method to receive a message, which gets printed to the console
    public void ReceiveMessage(string message) {
        Console.WriteLine($"{name} received message: {message}");
    }
}

Next, we define a ChatRoom class with methods to display messages and manage the list of users in the chat room. This class will act as the subject in the Observer pattern.

class ChatRoom {
    // List to keep track of users in the chat room
    private List<User> users = new List<User>();

    // Method to display message in chat room
    public void ShowMessage(string message) {
        Console.WriteLine($"Message: {message}");
    }

    // Method to add a user to the chat room
    public void AddUser(User user) {
        users.Add(user);
    }

    // Method to send message to all users in chat room
    public void SendMessage(string message) {
        foreach (var user in users) {
            user.ReceiveMessage(message);
        }
    }
}

Finally, the ChatCommand class implements the ICommand interface and encapsulates the action of showing a message. When creating a ChatCommand, you set the message and the chat room where the message will be displayed, then execute this command to display and broadcast the message.

class ChatCommand : ICommand {
    private ChatRoom chatRoom;
    private string message;

    // Constructor to initialize chat room and message
    public ChatCommand(ChatRoom chatRoom, string message) {
        this.chatRoom = chatRoom;
        this.message = message;
    }

    // Execute method to show and send message in chat room
    public void Execute() {
        chatRoom.ShowMessage(message);
        chatRoom.SendMessage(message);
    }
}

Below is the combined structure of our chat application. This demonstrates how the Command and Observer patterns work together:

class Program {
    static void Main() {
        // Creating chat room
        ChatRoom chatRoom = new ChatRoom();
        
        // Creating users
        User user1 = new User("Alice");
        User user2 = new User("Bob");

        // Adding users to chat room
        chatRoom.AddUser(user1);
        chatRoom.AddUser(user2);

        // Creating and executing chat command
        ICommand chatCommand = new ChatCommand(chatRoom, "Hello, everyone!");
        chatCommand.Execute();
        // Output:
        // Message: Hello, everyone!
        // Alice received message: Hello, everyone!
        // Bob received message: Hello, everyone!
    }
}

In this structure:

• The ChatRoom acts as a central hub.
• Commands encapsulate user actions such as sending messages.
• Users observe the chat room and receive messages when they are sent.

By the end of this unit, you will have a functional chat application in which messages can be sent and received efficiently. You will also have a deeper understanding of how combining multiple behavioral patterns can solve complex real-world problems effectively. Let’s get started with the practice section and see these concepts come to life in our chat application!