Mastering In CoreData (Part 2 Core Data Stack)

Core Data Stack

It’s very important to understand Core Data stack. Many developers don’t take time to learn about it which makes their life hell while using Core Data. The Core Data stack is a collection of framework objects that are accessed as part of the initialization of Core Data and that mediate between the objects in your application and external data stores. This stack provides all the features or task associated with data model layer objects. The features we discussed in part 1

A Core Data stack is composed of the following objects → one or more managed object contexts connected to a single persistent store coordinator which is in turn connected to one or more persistent stores.

Managed Object Context (MOC)

Its primary responsibility is to manage a collection of Managed Objects (Entities). A Managed Object Context maintains the state of entities, typically in memory.

When an operation on such objects is completed, you save such MOC, typically down to the Persistent Store coordinator to persistent store

It’s sit on top of Core Data stack and your application will interact with the most, and therefore it is the one that is exposed to the rest of your application

Application can create one or more MOC per stack. Context is connected to persistent store coordinator or from parent context

It provides Caching, Change tracking, Lazy loading, Redo, Undo and validation features

Persistent Store Coordinator (PSC)

Instance of NSPersistentStoreCoordinator. The coordinator is the central object in a Core Data stack.

The persistent store coordinator role is to manage multiple/single stores and present to its managed object contexts the facade of a single unified store as shown below in the figure coordinator communicating to multiple stores.

It has a reference to a managed object model as shown below in the figure 2.1. Persistent store coordinator can talk or have a reference of the majority of the components in a stack

Persistent store

You can think of a persistent store as a database file (Sqlite) where individual records each hold the last-saved values of a managed object (Entity).

Core Data also provides an in-memory store that lasts no longer than the lifetime of a process

We can make multiple persistent stores per stack

Core Data offers three native file types for a persistent store: binary, XML, and SQLite. You can implement your own store type if you want Core Data to interoperate with a custom file format or server

Managed Object

Instance of NSManagedObject. It represents a record from a persistent store

A managed object is registered with a managed object context. In any given context, there is at most one instance of a managed object that corresponds to a given record in a persistent store

Managed object model

A managed object model is a set of objects that together form a blueprint describing the managed objects you use in your application

Schema of the model objects you use in your application

Persistent object store

A persistent object store maps between objects in your application and records in a persistent store.

There are different classes of persistent object store for the different file types that Core Data supports

You can also implement your own if you want to support a custom file type

You don’t create a persistent object store directly. Instead, Core Data creates a store of the appropriate type for you when you send
an addPersistentStoreWithType:configuration:URL:options:error: message to a persistent store coordinator.

Summary

In this part we discussed Core data stack. This part purpose is to put theoretical things in one place. If you don’t understand anything about core data stack don’t worry when we will be doing coding part these points will get clear when I will be referencing these points.
But you should take this point that Core data stack is essential for the working of Core data . All features that Core Data provides with the help of this stack. Core Data stack have many components each have their role . The top component is the MOC and the bottom component is the persistent store in which actual data is store.

Useful Links

https://store.raywenderlich.com/products/core-data-by-tutorials

https://www.objc.io/issues/4-core-data/core-data-overview/

https://en.wikipedia.org/wiki/Object-relational_mapping

https://cocoacasts.com/what-are-core-data-entities-and-attributes

https://cocoacasts.com/what-is-the-core-data-stack

https://developer.apple.com/library/archive/documentation/DataManagement/Devpedia-CoreData/coreDataStack.html

https://medium.com/@ankurvekariya/core-data-crud-with-swift-4-2-for-beginners-40efe4e7d1cc

https://www.raywenderlich.com/7569-getting-started-with-core-data-tutorial

https://developer.apple.com/library/archive/qa/qa1952/_index.html

--

--

--

Senior iOS Engineer | HungerStation | Delivery Hero

Love podcasts or audiobooks? Learn on the go with our new app.

Recommended from Medium

Serverless Orchestration Using Cloudify

Are Coding Boot Camps Worth It?

Green IT — Are We as Software Engineers Doing Enough?

Adaptive music for an adaptive world

Conducto for CI/CD

Under the Hood of Effective Game Testing

Amazon Redshift Spectrum

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Ali Akhtar

Ali Akhtar

Senior iOS Engineer | HungerStation | Delivery Hero

More from Medium

How to prevent Xcode from asking for ‘required’ initializer ‘init(coder:)’ in every subclass of…

iOS-DispatchQueue and its WorkItem

Execute Apollo GraphQL Query in iOS

iOS: Asset Catalogs, UIButton, CALayer & More…