Swift simple factory design pattern
This time let's talk about the simple factory design pattern to encapsulate object creation in a really simple way using Swift.
Simple factory implementation using switch-case
The goal of this pattern is to encapsulate something that can often vary. Imagine a color palette for an application. You might have to change the colors according to the latest habit of the designer on a daily basis. I'd be really inconvenient if you had to search & replace every single instance of the color code by hand. So let's make a simple factory in Swift that can return colors based on a given style. 🎩
class ColorFactory {
enum Style {
case text
case background
}
func create(_ style: Style) -> UIColor {
switch style {
case .text:
return .black
case .background:
return .white
}
}
}
let factory = ColorFactory()
let textColor = factory.create(.text)
let backgroundColor = factory.create(.background)
This can be really useful, especially if it comes to a complicated object initialization process. You can also define a protocol and return various instance types that implement the required interface using a switch case block. 🚦
protocol Environment {
var identifier: String { get }
}
class DevEnvironment: Environment {
var identifier: String { return "dev" }
}
class LiveEnvironment: Environment {
var identifier: String { return "live" }
}
class EnvironmentFactory {
enum EnvType {
case dev
case live
}
func create(_ type: EnvType) -> Environment {
switch type {
case .dev:
return DevEnvironment()
case .live:
return LiveEnvironment()
}
}
}
let factory = EnvironmentFactory()
let dev = factory.create(.dev)
print(dev.identifier)
So, a few things to remember about the simple factory design pattern:
- it helps loose coupling by separating init & usage logic 🤔
- it's just a wrapper to encapsulate things that can change often 🤷♂️
- simple factory can be implemented in Swift using an enum and a switch-case
- use a protocol if you are planning to return different objects (POP 🎉)
- keep it simple 🏭
This pattern separates the creation from the actual usage and moves the responsibility to a specific role, so if something changes you only have to modify the factory. You can leave all your tests and everything else completely untouched. Powerful and simple! 💪