了解iOS Swift中的CoreData

Question

I am building an app at the moment and am trying to get my head around the concept of CoreData. I have created a data model for the app based on the advice from this link...

Apple "Define Your Data Model" Link

Currently, I am just using some test data locally for development purposes. Here is the sample object class I have created...

import UIKit

func ==(lhs: Recipe, rhs: Recipe) -> Bool {
    return lhs.hashValue == rhs.hashValue
}

class Recipe: Hashable {

dynamic var ID : Int = 0
dynamic var recipeName: String = ""
dynamic var recipeDescription:String = ""
dynamic var servings: Int = 0
dynamic var cookTime: Double = 0.0
dynamic var image: String? = ""

var hashValue : Int {
    get {
        return "\(self.ID)".hashValue
    }
}
init?(id: Int, name: String, description: String, servings: Int, cooktime: Double, image: String) {
    self.ID = id
    self.recipeName = name
    self.recipeDescription = description
    self.servings = servings
    self.cookTime = cooktime
    self.image = image

    if id < 0 || name.isEmpty || description.isEmpty || cookTime < 0 || servings < 0 {
        return nil
    }
}
}

I have then initialized some of those objects locally to be used during development and they work fine.

My question is...

When it comes time to use storage like CoreData or RealmSwift, will this type of data model be irrelevant? Will I make an entirely new data model (in Realm for example)? or will this type of data model play nicely with one of the DB models?

Most importantly, will building my data model like this now and incorporating CoreData or RealmSwift after be the cause of a lot of code refactoring? If this is the case then would it be advisable to drop the frontend development and build the entire data model before moving forward?

Answer 1

Core Data and Realm go two very different approaches for defining your schema.

For Core Data, you need to design your model in Xcode's Data Model editor, which creates a bundle of xcdatamodel files for each version. You can then either use Xcode built-in capabilities or some third party tooling as mogenerator to generate your NSManagedObject entity classes. Core Data can automatically infer a mapping between different versions of your schema with lightweight migrations , but this works only within certain limitations. If your migration case should be more complex, you can define custom mapping models.

With Realm in general and RealmSwift specifically here, you define your schema (and migrations) completely in code. Your classes have to inherit from Object and you have to define your properties conforming to some rules , so that they are recognized correctly and can be automatically persisted.

But the decision for one persistency framework over the other will have application-wide effects. For example Core Data and Realm have different requirements regarding multi-threading. While you can theoretically avoid that if you encapsulate your persistency layer completely and share only proxy objects with your frontend, you'll loose at the same time the advantage of component support ( NSFetchedResultsController / RBQFetchedResultsController ) and further conveniences the persistency framework may offer. (eg change notifications, auto-updates, …)