Scribd
Upload
7 views4 pages

Explain Command Pattern

Uploaded by

Szymon Michalak
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
7 views4 pages

Explain Command Pattern

Uploaded by

Szymon Michalak
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

**Sources & Resources**

Main Source: Ray Wenderlich - Design Patterns by Tutorials (2019)


Further Reading:

Command Pattern in iOS by Apple

:::info[TL/DR]
The Command Pattern encapsulates requests or actions into objects. This allows you to parameterize methods, queue operations, and
support undo functionality.
:::

Concept Overview
The Command Pattern is a behavioral design pattern that turns a request or action into a command object, which can then be executed,
delayed, or queued. The three primary components are:

1. Invoker: Stores and executes commands.

2. Command: Encapsulates the action to be performed.

3. Receiver: The object that the command is performed on.

This pattern is often used in situations where actions need to be executed at a later time or reversed (for undo functionality).

Playground Example
Below is an example based on a door control system from the book:

import Foundation

// MARK: - Receiver
public class Door {
public var isOpen = false
}
// MARK: - Command
public class DoorCommand {
public let door: Door
public init(_ door: Door) {
self.door = door
}
public func execute() {}
}

public class OpenCommand: DoorCommand {


public override func execute() {
print("Opening the door...")
door.isOpen = true
}
}

public class CloseCommand: DoorCommand {


public override func execute() {
print("Closing the door...")
door.isOpen = false
}
}

// MARK: - Invoker
public class Doorman {
public let commands: [DoorCommand]
public let door: Door

public init(door: Door) {


let commandCount = arc4random_uniform(10) + 1
self.commands = (0..<commandCount).map { index in
return index % 2 == 0 ? OpenCommand(door) : CloseCommand(door)
}
self.door = door
}
public func execute() {
print("Doorman is executing commands...")
commands.forEach { $0.execute() }
}
}

// Example usage
let door = Door()
let doorman = Doorman(door: door)
doorman.execute()

How It Works:
Receiver: The Door class acts as the receiver that will be opened or closed by the command.

Command: The OpenCommand and CloseCommand encapsulate the actions of opening and closing the door.

Invoker: The Doorman class stores and executes the commands in sequence.

When to Use
Queuing and executing actions: When you need to queue operations to be performed later, or support undo functionality.

Decoupling requesters from executors: When the requester (e.g., user interface) should be decoupled from the object that performs
the action.

When to Be Careful
Complex command objects: Be cautious of creating too many command objects, as it can lead to more complex and harder-to-maintain
code.

:::tip[In Bullets]
The Command Pattern turns actions into objects that can be stored and executed later.

It involves three main components: invoker, command, and receiver.

Useful for queuing, undo functionality, or decoupling requesters from actions.


:::

You might also like