Swift: The proper way to initialize model class with a lot of properties

Question

How do you initialize your classes/structs with a lot of properties?

This question could probably be asked without Swift context but Swift brings a flavour to it, so I add Swift tag in headline and tags.

Let's say you have a User class with 20 properties. Most of them should not be nil or empty. Let's assume these properties are not interdependent. Let's assume that 33% of it should be constant (let) by the logic of the class. Let's assume that at least 65% of them do not have meaningful default values. How would you design this class and initialize an instance of it?

So far I have few thoughts but none of it seems to be completely satisfactory to me:

put all of the properties linearly in the class and make huge init method:

class User {
    // there is 20 properties like that
    let id : String
    let username : String
    let email : String
    ...
    var lastLoginDate : Date
    var lastPlayDate : Date

    // then HUUUUGE init
    init(id: String, 
         username: String,
         ...
         lastPlayDate: Date) {
    }
}

try to group properties into sub types and deal with smaller inits separately

class User {
    struct ID {
        let id : String
        let username : String
        let email : String
    }
    struct Activity {
        var lastLoginDate : Date
        var lastPlayDate : Date 
    }
    let id : ID
    ...
    var lastActivity : Activity

    // then not so huge init
    init(id: ID, 
         ...
         lastActivity: Activity) {
    }
}

another solution is to break requirements a bit: either declare some of the properties optional and set values after init or declare dummy default values and set normal values after init, which conceptually seems to be the same

class User {
    // there is 20 properties like that
    let id : String
    let username : String
    let email : String
    ...
    var lastLoginDate : Date?
    var lastPlayDate : Date?

    // then not so huge init
    init(id: String, 
         username: String,
         email: String) {
    }
}

// In other code 
var user = User(id: "1", username: "user", email: "user@example.com"
user.lastLoginDate = Date()

Is there a nice paradigm/pattern how to deal with such situations?

You can use the Builder pattern: http://stackoverflow.com/questions/33106041/how-do-i-initialize-classes-with-lots-of-fields-in-an-elegant-way — sdasdadas, Feb 13 '17 at 11:34
No good options =/. I like .net's solution which is to provide built in initializer. looks something like this: className{prop1=1,prop2=2}. — bj97301, May 11 '18 at 18:33

score 3 · Answer 1 · edited Jun 20 '20 at 09:12

You can try the builder pattern.

Example

class DeathStarBuilder {

    var x: Double?
    var y: Double?
    var z: Double?

    typealias BuilderClosure = (DeathStarBuilder) -> ()

    init(buildClosure: BuilderClosure) {
        buildClosure(self)
    }
}

struct DeathStar : CustomStringConvertible {

    let x: Double
    let y: Double
    let z: Double

    init?(builder: DeathStarBuilder) {

        if let x = builder.x, let y = builder.y, let z = builder.z {
            self.x = x
            self.y = y
            self.z = z
        } else {
            return nil
        }
    }

    var description:String {
        return "Death Star at (x:\(x) y:\(y) z:\(z))"
    }
}

let empire = DeathStarBuilder { builder in
    builder.x = 0.1
    builder.y = 0.2
    builder.z = 0.3
}

let deathStar = DeathStar(builder:empire)

Example taken from here: https://github.com/ochococo/Design-Patterns-In-Swift

If you are looking for a bit more Java like solution, you can try something like this.

Alternative Example

final class NutritionFacts {
    private let servingSize: Int
    private let servings: Int
    private let calories: Int
    private let fat: Int
    private let sodium: Int
    private let carbs: Int
 
    init(builder: Builder) {
        servingSize = builder.servingSize
        servings = builder.servings
        calories = builder.calories
        fat = builder.fat
        sodium = builder.sodium
        carbs = builder.carbs
    }
 
    class Builder {
        let servingSize: Int
        let servings: Int
 
        private(set) var calories = 0
        private(set) var fat = 0
        private(set) var carbs = 0
        private(set) var sodium = 0
 
        init(servingSize: Int, servings: Int) {
            self.servingSize = servingSize
            self.servings = servings
        }
 
        func calories(value: Int) -> Builder {
            calories = value
            return self
        }
 
        func fat(value: Int) -> Builder {
            fat = value
            return self
        }
 
        func carbs(value: Int) -> Builder {
            carbs = value
            return self
        }
 
        func sodium(value: Int) -> Builder {
            sodium = value
            return self
        }
 
        func build() -> NutritionFacts {
            return NutritionFacts(builder: self)
        }
    }
}
 
let facts = NutritionFacts.Builder(servingSize: 10, servings: 1)
    .calories(value: 20)
    .carbs(value: 2)
    .fat(value: 5)
    .build()

Example taken from: http://ctarda.com/2017/09/elegant-swift-default-parameters-vs-the-builder-pattern

Swift: The proper way to initialize model class with a lot of properties

1 Answers1

Example

Alternative Example