Overview

The Command design pattern plays a crucial role in software design by encapsulating a request as an object, thereby allowing developers to parameterize clients with queues, requests, and operations. It enhances code flexibility by enabling the issuing of requests to objects without knowing anything about the operation being performed or the request's destination.

Key Concepts

1. Encapsulation of Requests: Commands encapsulate all the information needed to perform an action or trigger an event, including the method name, the object that owns the method, and the method parameters.
2. Separation of Concerns: It separates the object that invokes the operation from the one that knows how to perform it, enhancing modularity and flexibility.
3. Undo/Redo Operations: The Command pattern allows for the implementation of undoable operations. By storing the history of commands, an application can roll back operations or redo them.

Common Interview Questions

Basic Level

1. What is the Command design pattern and why is it used?
2. Can you write a simple implementation of the Command pattern in C#?

Intermediate Level

3. How does the Command pattern contribute to the principle of separation of concerns?

Advanced Level

4. Discuss how the Command pattern can be used to implement macro recording or undo functionality in an application.

Detailed Answers

1. What is the Command design pattern and why is it used?

Answer: The Command design pattern is a behavioral design pattern that turns a request into a stand-alone object containing all information about the request. This transformation allows command objects to be used and manipulated like any other object, which is particularly useful for parameterizing objects by an action, scheduling requests, and implementing reversible operations. It is used to decouple the objects that send a request from the objects that receive and execute those requests, enhancing flexibility and scalability in the software design.

Key Points:
- Encapsulates a request as an object.
- Decouples the sender and receiver.
- Enhances flexibility in how requests are executed.

Example:

public interface ICommand
{
    void Execute();
}

public class LightOnCommand : ICommand
{
    private Light _light;

    public LightOnCommand(Light light)
    {
        _light = light;
    }

    public void Execute()
    {
        _light.On();
    }
}

public class Light
{
    public void On()
    {
        Console.WriteLine("Light is on");
    }

    public void Off()
    {
        Console.WriteLine("Light is off");
    }
}

2. Can you write a simple implementation of the Command pattern in C#?

Answer: Yes, a simple implementation involves creating a command interface with an Execute method and concrete command classes that implement this interface. Each command class encapsulates the action and its parameters.

Key Points:
- Define an ICommand interface with an Execute method.
- Implement this interface in concrete command classes.
- Invoke the command's Execute method to perform the action.

Example:

public class RemoteControl
{
    private ICommand _command;

    public void SetCommand(ICommand command)
    {
        _command = command;
    }

    public void PressButton()
    {
        _command.Execute();
    }
}

// Usage
public class Program
{
    public static void Main(string[] args)
    {
        Light light = new Light();
        ICommand lightOn = new LightOnCommand(light);

        RemoteControl remote = new RemoteControl();
        remote.SetCommand(lightOn);
        remote.PressButton();
    }
}

3. How does the Command pattern contribute to the principle of separation of concerns?

Answer: The Command pattern contributes to the principle of separation of concerns by decoupling the classes that issue a request from the classes that process the request. This separation allows for more modular and maintainable code, as changes to the request's execution logic do not affect the client code that initiates these requests.

Key Points:
- Decouples sender and receiver.
- Enhances modularity through focused class responsibilities.
- Simplifies code maintenance and evolution.

Example:

// In this example, the RemoteControl (sender) is decoupled from the Light (receiver) using the Command pattern.

// Already shown LightOnCommand and Light classes above can be referenced here.

4. Discuss how the Command pattern can be used to implement macro recording or undo functionality in an application.

Answer: The Command pattern is ideal for implementing macros and undo functionality because it encapsulates all the information needed for an action. For macros, commands can be stored in a list as they are executed, allowing for replay. For undo, commands can implement an Undo method that reverses the action executed by the Execute method. Storing a history of commands allows an application to walk back through the actions performed.

Key Points:
- Store commands executed in a list for macro recording.
- Implement an Undo method in commands for undo functionality.
- Maintain a history of commands for undo operations.

Example:

public interface ICommand
{
    void Execute();
    void Undo();
}

// Assuming LightOnCommand and Light classes are implemented as before
public class LightOnCommand : ICommand
{
    private Light _light;

    public LightOnCommand(Light light)
    {
        _light = light;
    }

    public void Execute()
    {
        _light.On();
    }

    public void Undo()
    {
        _light.Off();
    }
}

// Usage of undo functionality
public class Program
{
    public static void Main(string[] args)
    {
        Light light = new Light();
        ICommand lightOn = new LightOnCommand(light);

        // Execute command
        lightOn.Execute();

        // Undo command
        lightOn.Undo();
    }
}