Taming Core Data by Arek Holko, Macoscope

Taming
Core
Data
CocoaHeads Berlin

Arkadiusz Holko
@arekholko
holko.pl

Core Data is a framework that you use
to manage the model layer objects in
your application.

A framework that you use to build the
persistence layer in your application.

NSManagedObjectContext
Similar to:
» sqlite3 *
» RLMRealm */Realm

Fetch
class TweetListViewController: UITableViewController {
...
func fetchTweets() {
let application = UIApplication.sharedApplication()
guard let appDelegate = application.delegate as? AppDelegate else { return }
let managedObjectContext = appDelegate.managedObjectContext
}
}

Fetch ?
...
let fetchRequest = NSFetchRequest(entityName: "ManagedTweet")
fetchRequest.predicate = NSPredicate(format: "homeTimeline != NULL")
fetchRequest.sortDescriptors = [NSSortDescriptor(key: "identiﬁer",
ascending: false)]
}
}

Fetch ?!
...
let fetchRequest = NSFetchRequest(entityName: "ManagedTweet")
fetchRequest.predicate = NSPredicate(format: "homeTimeline != NULL")
fetchRequest.sortDescriptors = [NSSortDescriptor(key: "identiﬁer",
ascending: false)]
let results = try? managedObjectContext.executeFetchRequest(fetchRequest)
if let managedObjects = results as? [NSManagedObject] {
data = managedObjects
}
}
}

data property
...
var data: [ManagedTweet] = [] {
didSet {
tableView.reloadData()
}
}
}

cellForRowAtIndexPath:
override func tableView(tableView: UITableView,
cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentiﬁer(reuseIdentiﬁer,
forIndexPath: indexPath) as! TweetTableViewCell
}

let tweet = data[indexPath.row]
}

let tweet = data[indexPath.row]
if let text = tweet.valueForKey("text") as? String {
cell.multilineTextLabel?.text = text
}
// set up other views
return cell
}

The app delegate works alongside the
app object to ensure your app interacts
properly with the system and with
other apps.
— Apple

PersistentStack
class PersistentStack {
let managedObjectContext: NSManagedObjectContext
init(storeType: String) {
...
}
}

AppDelegate now
class AppDelegate: UIResponder, UIApplicationDelegate {
let persistentStack = PersistentStack(NSSQLiteStoreType)
...
}

Step #2
–
Accessing
NSManagedObjectContext

The Easy Way
init() {
if let appDelegate = UIApplication.sharedApplication().delegate as? AppDelegate {
managedObjectContext = appDelegate.persistentStack.managedObjectContext
}
super.init(nibName: nil, bundle: nil)
}
}

Singleton
init() {
managedObjectContext = PersistentStack.sharedInstance().managedObjectContext
}
}

Dependency Injection
init(managedObjectContext: NSManagedObjectContext) {
self.managedObjectContext = managedObjectContext
}
}

Step #3
–
NSManagedObject subclass

NSManagedObject with KVC
let tweet: NSManagedObject = data[indexPath.row]
if let text = tweet.valueForKey("text") as? String {
cell.multilineTextLabel?.text = text
}

Subclassed NSManagedObject
let tweet: ManagedTweet = data[indexPath.row]
cell.multilineTextLabel.text = tweet.text

Generators
» Xcode: Editor → Create NSManagedObject subclass...
» mogenerator

class _ManagedTweet: NSManagedObject {
...
// MARK: - Properties
@NSManaged
var identiﬁer: NSNumber
@NSManaged
var text: String
// MARK: - Relationships
@NSManaged
var homeTimeline: ManagedHomeTimeline?
@NSManaged
var user: ManagedUser
}

enum ManagedTweetAttributes: String {
case identiﬁer = "identiﬁer"
case text = "text"
}
enum ManagedTweetRelationships: String {
case homeTimeline = "homeTimeline"
case user = "user"
}

Step #4
–
Who should create NSFetchRequest?

Data Manager?
class DataManager {
}

Repository
class TweetListRepository {
}
...
}

class TweetListRepository {
...
func performFetch(completion: [ManagedTweet] -> Void) {
let fetchRequest = NSFetchRequest(entityName: ManagedTweet.entityName())
let homeTimelineKey = ManagedTweetRelationships.homeTimeline.rawValue
fetchRequest.predicate = NSPredicate(format: "%@ != NULL",
homeTimelineKey);
let identifierKey = ManagedTweetAttributes.identifier.rawValue
fetchRequest.sortDescriptors = [NSSortDescriptor(key: identifierKey,
ascending: false)]
let results = try? managedObjectContext.executeFetchRequest(fetchRequest)
if let managedTweets = results as? [ManagedTweet] {
completion(managedTweets)
}
}
}

Impact on the view controller
override func viewDidLoad() {
super.viewDidLoad()
setupTableView()
repository.performFetch { [weak self] managedTweets -> Void in
self?.data = managedTweets
}
}

NSManagedObjectContext gets hidden from
the view controller
let repository: TweetListRepository
init(repository: TweetListRepository) {
self.repository = repository
}
...
}

Data repositories' flow
class ProfileRepository {
let profileIdentifier: Int
init(managedObjectContext: NSManagedObjectContext, profileIdentifier: Int) {
self.profileIdentifier = profileIdentifier
}
}

protocol Repository {
var managedObjectContext: NSManagedObjectContext { get }
}
extension ProfileRepository {
convenience init(repository: Repository, profileIdentifier: Int64) {
self.init(managedObjectContext: repository.managedObjectContext,
profileIdentifier: profileIdentifier)
}
}
let profileRepository = ProfileRepository(repository: repository,
profileIdentifier: profileIdentifier)
let viewController = ProfileViewController(repository: profileRepository)

protocol Request {
typealias ResultType
var method: Method { get }
var path: String { get }
var parameters: Dictionary<String, String> { get }
func send(completion: (Result<ResultType, NSError> -> Void))
func resultFromJSON(JSON: AnyObject) throws -> ResultType
}
Result: github.com/antitypical/Result

extension Request {
var method: Method { return .GET }
var path: String { return "" }
var parameters: Dictionary<String, String> { return Dictionary() }
}

extension Request {
var method: Method { return .GET }
var path: String { return "" }
var parameters: Dictionary<String, String> { return Dictionary() }
func send(completion: (Result<ResultType, NSError> -> Void)) {
let response = RequestSender().send(self)
do {
let result = try self.resultFromJSON(response)
completion(Result(result))
} catch let nserror as NSError {
completion(Result(error: nserror))
}
}
}

struct Tweet {
let identiﬁer: Int
let text: String
let user: User
}
struct User {
let name: String
let proﬁleImageUrl: String?
let screenName: String
}

class TweetListRequest: Request {
typealias ResultType = [Tweet]
var path: String { return "statuses/home_timeline" }
func resultFromJSON(JSON: AnyObject) throws -> [Tweet] {
return try [Tweet].decode(JSONString)
}
}
decode: github.com/Anviking/Decodable

class TweetListImporter {
}
func importTweets(tweets: [Tweet],
completion: (Result<Bool, NSError> -> Void)) {
...
}
}

Value Type → NSManagedObject
» Objective-C
» Mantle with MTLManagedObjectAdapter
» Swift
» CoreValue, but too powerful
» own solution similar to JSON parsing libraries, such as Argo
or Decodable

Step #6
–
NSFetchedResultsController
!

Problem with
NSFetchedResultsControllerDelegate
optional public func controller(controller: NSFetchedResultsController,
didChangeObject anObject: AnyObject,
atIndexPath indexPath: NSIndexPath?,
forChangeType type: NSFetchedResultsChangeType,
newIndexPath: NSIndexPath?)

Problem with
NSFetchedResultsControllerDelegate
didChangeObject anObject: AnyObject,

TweetListRepository API
class TweetListRepository: Repository {
weak var delegate: NSFetchedResultsControllerDelegate?
var objects: [ManagedTweet] // computed property
}

TweetListRepository API
weak var delegate: RepositoryDelegate?
var objects: [ManagedTweet] // computed property
}

Our own delegate
protocol Repository {
func performFetch()
}
protocol RepositoryDelegate: class {
func repository(repository: Repository, didFinishInitialRequestWithResult
result: Result<Bool, NSError>)
func repositoryWillChangeContent(repository: Repository)
func repositoryDidChangeContent(repository: Repository)
func repository(repository: Repository, didInsertRowAtIndexPath indexPath: NSIndexPath)
func repository(repository: Repository, didDeleteRowAtIndexPath indexPath: NSIndexPath)
func repository(repository: Repository, didUpdateRowAtIndexPath indexPath: NSIndexPath)
}

From NSFRCDelegate to RepositoryDelegate
// other delegate methods omitted for clarity
func controller(controller: NSFetchedResultsController, didChangeObject anObject: AnyObject,
atIndexPath indexPath: NSIndexPath?, forChangeType type: NSFetchedResultsChangeType,
newIndexPath: NSIndexPath?) {
switch (type) {
case .Insert:
delegate?.repository(self, didInsertRowAtIndexPath: newIndexPath!)
case .Delete:
delegate?.repository(self, didDeleteRowAtIndexPath: indexPath!)
case .Update:
delegate?.repository(self, didUpdateRowAtIndexPath: indexPath!)
case .Move:
// consider adding separate update callback
delegate?.repository(self, didDeleteRowAtIndexPath: indexPath!)
delegate?.repository(self, didInsertRowAtIndexPath: newIndexPath!)
}
}
}

Reacting to changes
extension TweetListViewController: RepositoryDelegate {
// some methods omitted
func repository(repository: Repository, didInsertRowAtIndexPath indexPath: NSIndexPath) {
tableView.insertRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
}
func repository(repository: Repository, didDeleteRowAtIndexPath indexPath: NSIndexPath) {
tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
}
func repository(repository: Repository, didUpdateRowAtIndexPath indexPath: NSIndexPath) {
tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: .Automatic)
}
}

NSFetchedResultsController
Not only for
table/collection views

ProﬁleRepository
protocol SingleElementRepository {
func performFetch()
}
protocol SingleElementRepositoryDelegate: class {
func singleElementRepositoryDidUpdate(repository: SingleElementRepository)
}
class ProﬁleRepository: SingleElementRepository {
weak var delegate: SingleElementRepositoryDelegate?
var user: User? // computed property
...
}

Issues
» mutability
» faulting
» lack of thread safety

protocol TweetType {
var identifier: Int { get }
var text: String { get }
var user: UserType { get }
}
protocol UserType {
var identifier: Int { get }
var name: String { get }
var profileImageUrl: String? { get }
var screenName: String { get }
}

var objects: [TweetType] // computed property
}

Those Structs
struct Tweet: TweetType {
let text: String
let user: User
}
struct User: UserType {
let name: String
let proﬁleImageUrl: String?
let screenName: String
}

var objects: [TweetType] {
// non-optimized version
let fetchedObjects = fetchedResultsController.fetchedObjects
return structsFromManagedObjects(fetchedObjects)
}
}

Mutation
func favoriteTweet(tweet: TweetType) {
// modiﬁes corresponding managed object under the hood
}

New Issues
» data duplication in memory
» CPU time for conversions (can be in the background)
» possible lack of synchronization

Lessons learned
» small classes/structs
» testability
» separation of concerns

Can We
Take This
Even Further?

Slides
https://speakerdeck.com/fastred/taming-core-data-cocoaheads

Links (1/2)
» https://www.youtube.com/watch?v=WpkDN78P884
» https://www.destroyallsoftware.com/talks/boundaries
» http://objectsonrails.com/
» http://blog.8thlight.com/uncle-bob/2012/08/13/the-clean-
architecture.html
» https://realm.io/news/andy-matuschak-controlling-
complexity/

Links (2/2)
» http://khanlou.com/2015/06/protocol-oriented-networking/
» https://twitter.com/andy_matuschak/status/
560857237640343552
» https://github.com/rentzsch/mogenerator
» https://www.objc.io/issues/13-architecture/viper/
» https://developers.facebooklive.com/videos/525/facebook-
on-ios-inside-the-big-blue-app

Taming Core Data by Arek Holko, Macoscope

Recommended

More Related Content

What's hot (19)

Similar to Taming Core Data by Arek Holko, Macoscope (20)

Recently uploaded (20)

Taming Core Data by Arek Holko, Macoscope