Applying the Command Pattern in C#: A UserService CRUD Transformation

The Command Pattern is a behavioural design pattern that encapsulates a request as an object, allowing for parameterization of clients with queues, requests, and operations. In this article, we’ll explore how to apply the Command Pattern in a classic CRUD (Create, Read, Update, Delete) scenario for a UserService in C#.

Understanding the Command Pattern

The Command Pattern consists of four main components:

1. Command: An abstract class or interface defining an Execute method that concrete command classes must implement.
2. ConcreteCommand: Concrete classes that extend the Command class, encapsulating specific operations.
3. Invoker: An object that requests a command to perform a particular operation.
4. Receiver: The object that performs the actual operation.

Real-World Analogy: Restaurant Orders

Scenario: Imagine you’re at a restaurant, and you want to place an order for your meal. The interaction between you (the client) and the waiter (the invoker) can be likened to the Command Pattern.

1. Command (Order):
   • In this scenario, the command is equivalent to your meal order. Each menu item represents a specific command. For example, ordering a « Grilled Chicken Salad » is a command, and so is ordering a « Margherita Pizza. »
2. Concrete Command (Specific Order):
   • Concrete commands are specific instances of your order. If you order the « Grilled Chicken Salad, » that’s a concrete command. If you order a « Margherita Pizza, » that’s another concrete command. Each concrete command encapsulates the details of a particular dish.
3. Invoker (Waiter):
   • The waiter acts as the invoker in this analogy. You (the client) interact with the waiter to place your order (set the command). The waiter doesn’t need to know how the kitchen prepares each dish; their responsibility is to take your order and deliver it to the chef (receiver).
4. Receiver (Chef):
   • The chef is the receiver who carries out the actual command. When the waiter (invoker) takes your order, they pass it to the chef (receiver), who executes the command by preparing the specific dish you requested.

Now let’s apply this concept to a classic UserService.

Classic UserService CRUD

Let’s start with a simple UserService class that performs CRUD operations on a User entity.

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class UserService
{
    public void Create(User user)
    {
        // Logic to create a user
    }

    public User Read(int userId)
    {
        // Logic to retrieve a user
        return null;
    }

    public void Update(User user)
    {
        // Logic to update a user
    }

    public void Delete(int userId)
    {
        // Logic to delete a user
    }
}

Applying the Command Pattern

Now, let’s transform our classic UserService to use the Command Pattern.

Step 1: Define Command Interface

public interface ICommand
{
    void Execute();
}

Step 2: Create Concrete Command Classes

public class CreateUserCommand(User user) : ICommand
{
    public void Execute()
    {
       // Logic to add User
    }
}

// Similar classes for Read, Update, and Delete commands

Step 3: Implement Invoker

public class UserOperationInvoker
{
    private ICommand _command;

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

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

Step 4: Transform UserService

public class UserServiceWithCommand
{
    private readonly UserOperationInvoker _invoker;

    public UserServiceWithCommand(UserOperationInvoker invoker)
    {
        _invoker = invoker;
    }

    public void Create(User user)
    {
        var createCommand = new CreateUserCommand(user);
        _invoker.SetCommand(createCommand);
        _invoker.Execute();
    }

    public User Read(int userId)
    {
        // Similar logic for Read
        return null;
    }

    public void Update(User user)
    {
        // Similar logic for Update
    }

    public void Delete(int userId)
    {
        // Similar logic for Delete
    }
}

Utilizing the Command Pattern

Now, let’s see how to use our transformed UserServiceWithCommand.

class Program
{
    static void Main(string[] args)
    {
        var userOperationInvoker = new UserOperationInvoker();
        var userService = new UserServiceWithCommand(userOperationInvoker);

        var newUser = new User { Id = 1, Name = "John Doe" };

        // Using Command Pattern
        userService.Create(newUser);
        // Additional operations
        userService.Update(newUser);
        userService.Delete(newUser.Id);

        Console.ReadLine();
    }
}

Benefits of the Command Pattern

1. Decoupling: The Command Pattern decouples the sender and receiver of a request, allowing for more flexibility and easier maintenance.
2. Extensibility: It provides a simple way to add new commands without modifying existing code.
3. Undo/Redo Operations: The pattern supports undo/redo operations by storing command history.

Conclusion

The Command Pattern is a powerful tool for organizing and managing complex operations in an object-oriented system. In this article, we applied the Command Pattern to a classic UserService CRUD scenario, showcasing the benefits of decoupling and extensibility. Consider using the Command Pattern in your applications where flexibility and maintainability are essential.