Swift easy manufacturing unit design sample

Easy manufacturing unit implementation utilizing switch-case

The purpose of this sample is to encapsulate one thing that may usually fluctuate. Think about a shade palette for an utility. You might need to alter the colours in response to the most recent behavior of the designer each day. I’d be actually inconvenient should you needed to search & exchange each single occasion of the colour code by hand. So let’s make a easy manufacturing unit in Swift that may return colours based mostly on a given fashion. 🎩

class ColorFactory {

    enum Type {
        case textual content
        case background
    }

    func create(_ fashion: Type) -> UIColor {
        change fashion {
        case .textual content:
            return .black
        case .background:
            return .white
        }
    }
}


let manufacturing unit = ColorFactory()
let textColor = manufacturing unit.create(.textual content)
let backgroundColor = manufacturing unit.create(.background)

This may be actually helpful, particularly if it involves a sophisticated object initialization course of. You may as well outline a protocol and return numerous occasion varieties that implement the required interface utilizing a change case block. 🚦

protocol Atmosphere {
    var identifier: String { get }
}

class DevEnvironment: Atmosphere {
    var identifier: String { return "dev" }
}

class LiveEnvironment: Atmosphere {
    var identifier: String { return "stay" }
}

class EnvironmentFactory {

    enum EnvType {
        case dev
        case stay
    }

    func create(_ kind: EnvType) -> Atmosphere {
        change kind {
        case .dev:
            return DevEnvironment()
        case .stay:
            return LiveEnvironment()
        }
    }
}

let manufacturing unit = EnvironmentFactory()
let dev = manufacturing unit.create(.dev)
print(dev.identifier)

So, a couple of issues to recollect concerning the easy manufacturing unit design sample:

+ it helps unfastened coupling by separating init & utilization logic 🤔
+ it is only a wrapper to encapsulate issues that may change usually 🤷‍♂️
+ easy manufacturing unit will be applied in Swift utilizing an enum and a switch-case
+ use a protocol if you're planning to return completely different objects (POP 🎉)
+ hold it easy 🏭

This sample separates the creation from the precise utilization and strikes the duty to a selected position, so if one thing modifications you solely have to switch the manufacturing unit. You possibly can go away all of your exams and every part else fully untouched. Highly effective and easy! 💪