Swift static manufacturing unit design sample

Actual world static manufacturing unit sample examples

Named constructors

The primary advantage of the static manufacturing unit sample is that each static manufacturing unit technique can have a reputation. Apple makes use of this sample of their UIColor class implementation to create named colours like .purple, .yellow, and many others. Please notice that the implementation in Swift isn’t actually a way, however a static property, which returns the precise occasion.

public extension TimeInterval {
    public static var second: TimeInterval { return 1 }
    public static var minute: TimeInterval { return 60 }
    public static var hour: TimeInterval { return 3_600 }
    public static var day: TimeInterval { return 86_400 }
    public static var week: TimeInterval { return 604_800 }
}

If it is so exhausting to memorize what number of seconds is a day or per week why do not we create a named initializer for it. See? TimeInterval.week is a lot better than 604_800. 😅

Cached objects

The subsequent advantage of the static manufacturing unit sample is that it might help caching for the sake of higher reminiscence utilization. This fashion you may restrict the variety of objects created in case you are initializing it by way of the static constructor (aka. static manufacturing unit technique). 🏭

class Service {

    var title: String

    

    non-public static var cache: [String:Service] = [:]

    non-public static func cached(title: String) -> Service {
        if Service.cache[name] == nil {
            Service.cache[name] = Service(named: title)
        }
        return Service.cache[name]!
    }

    

    static var native: Service {
        return Service.cached(title: "native")
    }

    static var distant: Service {
        return Service.cached(title: "distant")
    }

    

    init(named title: String) {
        self.title = title
    }
}

Native initialization scope

One other advantage of static manufacturing unit strategies that you could restrict the initialization of a category to a non-public scope stage. In different phrases object creation will solely be out there by way of the static manufacturing unit technique. You simply should make the init technique non-public.

public closing class Service {

    var title: String

    non-public init(title: String) {
        self.title = title
    }

    public static var native: Service {
        return Service(title: "native")
    }

    public static var distant: Service {
        return Service(title: "distant")
    }
}

Be aware that you could limit subclassing with the ultimate & static key phrase. If you wish to enable subclassing you need to take away closing and use the class key phrase as a substitute of the static for the properties, this fashion subclasses can override manufacturing unit strategies. 🤔

Statically return something

Static manufacturing unit may return subtypes of a given object, however why do not we take this even one step additional? You too can return any form of kind from a static technique, I do know this looks like a cheat, as a result of I am not creating an occasion of UIColor right here, however I consider that it is value to say this technique right here, as a result of it is intently associated to static factories. This method may be actually helpful generally. 😛

extension UIColor {

    non-public static func picture(with shade: UIColor) -> UIImage {
        let rect = CGRect(x: 0, y: 0, width: 1, peak: 1)
        UIGraphicsBeginImageContext(rect.dimension)
        let context = UIGraphicsGetCurrentContext()!
        context.setFillColor(shade.cgColor)
        context.fill(rect)
        let img = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return img!
    }

    static var redImage: UIImage {
        return UIColor.picture(with: .purple)
    }
}