Latest Post

Dependency injection in swift SwiftUI interview questions and answer How to display SwiftUI sheet Half screen

 What is Core Data in Swift ?

Untitled 5
Core Data Stack

Core data with swift uses SqLite as  local DataBase Storage in iOS. it is the frameWork used to save, modify and track the data within our application.

Core data allows the developer to interact with the model layer in object oriented manner. It manages the object graph.

Object graph is the collection of object. Core data framework takes the care of managing the objects life cycle in object graph.

What are the Types of stores in core data

Core data supports the binary,XML and SQLite type of storage in iOS application.

Benefits of Core Data

  • Core data is default Apple framework to store data locally.
  • it is not the third party dependency, thus no need to worry about managing it .
  • It manages the data using object oriented graph. no need of data Management like insert, delete or save
  • Core Data take care of life cycle of the object in the object graph.

Drawbacks of Core data.

  • Core data is the framework not the database. It depends on Sql Database to store the data.
  • We needed to think data as Object oriented graph.
  • It is not the SQL Wrapper.

How Does core data stores the Data?

Core Data save the Data in the form of persistence Data .

The core data stack Contain the 4 segment.

1 NSManagementObjectContext

2. NSManageObjectModel

3. NSPresistentStoreCoordinator

4. NSPresistentContainer.

NSManagementObjectContext : It manages the object context and the collection of Object model.Each managed object context is backed by persistent store Coordinator . It is also Known as managed object context.

NSManageObjectModel: It is also a managed object model. it contains the information about the model or entites of the object graph

NSPresistentStoreCoordinator: Its called as A persistent store Coordinator. A Object persists data to disk and ensure the persistent store and the data model are compatible . It act as mediator between the Data model and persistent store

NSPresistentContainer: It s known as a persistent Store(storage). Its a repository in which managed object will be stored. Core data NSPresistentContainer  stores the file in the XML,binary and SQLite

 Core Data with Swift

Core Data, an attribute can be of one of several data types. Set the new attribute’s name to, er, name and change its type to String:


NSManagedObject represents a single object stored in Core Data; you must use it to create, edit, save and delete from your Core Data persistent store. As you’ll see shortly, NSManagedObject is a shape-shifter. It can take the form of any entity in your Data Model, appropriating whatever attributes and relationships you defined. This is where Core Data kicks in! Here’s what the code does:


1. Before you can save or retrieve anything from your Core Data store, you first need to get your hands on an NSManagedObjectContext. You can consider a managed object context as an in-memory “scratchpad” for working with managed objects.


Think of saving a new managed object to Core Data as a two-step process: first, you insert a new managed object into a managed object context; then, after you’re happy with your shiny new managed object, you “commit” the changes in your managed object context to save it to disk.


Xcode has already generated a managed object context as part of the new project’s template. Remember, this only happens if you check the Use Core Data checkbox at the beginning. This default managed object context lives as a property of the NSPersistentContainer in the application delegate. To access it, you first get a reference to the app delegate.

2. You create a new managed object and insert it into the managed object context. You can do this in one step with NSManagedObject’s static method: entity(forEntityName:in:).

You may be wondering what an NSEntityDescription is all about. Recall earlier, NSManagedObject was called a shape-shifter class because it can represent any entity. An entity description is the piece linking the entity definition from your Data Model with an instance of NSManagedObject at runtime.

3. With an NSManagedObject in hand, you set the name attribute using key-value coding. You must spell the KVC key (name in this case) exactly as it appears in your Data Model, otherwise your app will crash at runtime.

4. You commit your changes to person and save to disk by calling save on the managed object context. Note save can throw an error, which is why you call it using the try keyword within a do-catch block. Finally, insert the new managed object into the people array so it shows up when the table view reloads.


1. Before you can do anything with Core Data, you need a managed object context. Fetching is no different! Like before, you pull up the application delegate and grab a reference to its persistent container to get your hands on its NSManagedObjectContext.

2 .As the name suggests, NSFetchRequest is the class responsible for fetching from Core Data. Fetch requests are both powerful and flexible. You can use fetch requests to fetch a set of objects meeting the provided criteria (i.e. give me all employees living in Wisconsin and have been with the company at least three years), individual values (i.e. give me the longest name in the database) and more.


Fetch requests have several qualifiers used to refine the set of results returned. For now, you should know NSEntityDescription is a required one of these qualifiers.


Setting a fetch request’s entity property, or alternatively initializing it with init(entityName:), fetches all objects of a particular entity. This is what you do here to fetch all Person entities. Also note NSFetchRequest is a generic type. This use of generics specifies a fetch request’s expected return type, in this case NSManagedObject.


3. You hand the fetch request over to the managed object context to do the heavy lifting. fetch(_:) returns an array of managed objects meeting the criteria specified by the fetch request.

When we talk about persistent data, people probably think of database. If you are familiar with Oracle or MySQL, you know that relational database stores data in the form of table, row and column, and it usually facilitates access through what- so-called SQL query. However, don’t mix up Core Data with database.


Though SQLite database is the default persistent store for Core Data on iPhone, Core Data is not a relational database. It is actually a framework that lets developers store (or retrieve) data in database in an object-oriented way. With Core Data, you can easily map the objects in your apps to the table records in the database without even knowing any SQL.


What are relationships in core data?

Managed Object Model – It describes the schema that you use in the app. If you have a database background, think of this as the database schema. However, the schema is represented by a collection of objects (also known as entities). In Xcode, the Managed Object Model is defined in a file with the extension .xcdatamodeld.

You can use the visual editor to define the entities and their attributes, as well as, relationships.


Persistent Store Coordinator – SQLite is the default persistent store in iOS. However, Core Data allows developers to setup multiple stores containing different entities.


The Persistent Store Coordinator is the party responsible to manage different persistent object stores and save the objects to the stores. Forget about it you don’t understand what it is. You’ll not interact with Persistent Store Coordinator directly when using Core Data.

Managed Object Context – Think of it as a “scratch pad” containing objects that interacts with data in persistent store. Its job is to manage objects created and returned using Core Data. Among the components in the Core Data Stack, the Managed Object Context is the one you’ll work with for most of the time. In general, whenever you need to fetch and save objects in persistent store, the context is the first component you’ll talk to.

 Core data interview questions

Certainly! Here are some common interview questions related to Core Data in the context of Swift and iOS development:

What are the main components of Core Data?

Core Data consists of three main components: Managed Object Model, Managed Object Context, and Persistent Store Coordinator.

Explain the role of the Managed Object Context.

The Managed Object Context (NSManagedObjectContext) is responsible for managing and tracking the managed objects (data records) in memory. It serves as a scratchpad for changes made to the objects before they are saved to the persistent store.

What is a Managed Object Model?

The Managed Object Model (NSManagedObjectModel) defines the structure of the data model in terms of entities, attributes, relationships, and fetch requests. It acts as a schema for the Core Data objects.

How does Core Data handle data persistence?

Core Data uses a Persistent Store Coordinator to manage the interaction between the Managed Object Context and the actual data storage (persistent store). The persistent store can be a SQLite database, binary files, or other formats.

What is an NSManagedObject subclass?

NSManagedObject subclasses are generated by Xcode based on the entities defined in the Managed Object Model. These subclasses represent individual objects in the data model and provide a way to interact with the attributes and relationships of those objects using Swift or Objective-C code.

How do you fetch data from Core Data using a fetch request?

You can use NSFetchRequest to create queries to fetch data from Core Data. Fetch requests can include filters, sorting, and batching options. The fetched results can be used to populate tables, collection views, or other UI components.

Explain the concept of relationships in Core Data.

Relationships define how entities are related to each other in the data model. There are two main types of relationships: to-one and to-many. They allow you to establish connections between objects and navigate the object graph.

What is NSFetchedResultsController and when would you use it?

NSFetchedResultsController is a class provided by Core Data to efficiently manage and display data from a fetch request in a table view or collection view. It automatically updates the UI when changes occur in the managed object context.

How do you handle migrations in Core Data?

Core Data migrations are necessary when you modify your data model after data has been persisted. You create migration mappings to ensure that existing data is migrated to the new model without loss. This might involve creating or modifying mapping models.

What are some common performance considerations when using Core Data?

Performance considerations include using appropriate fetch request optimizations (such as batching and prefetching), managing relationships efficiently, and avoiding excessive faulting (loading data only when needed).

What is Core Data, and what is its primary purpose in iOS development?

Core Data is a framework provided by Apple that allows developers to manage the model layer objects in an iOS application. It provides an object-oriented approach to handling data persistence, including managing the object graph, data storage, and data manipulation.

What is FetchedResultController ?

FetchedResultController is the controller  is used to manage the data from the core Data using coreData fetch Request and display to the screen in UITableView.

How  to transfer manage object from from one Context(thread) to another ?

Each thread(Context) must have the own object context and object model . We can transfer object using the NSManagedObjectID. 

Do NSPersistentStoreCorordinor can have more persistent Store ?

Yes but needed to have relationShip between the object  in different store.

How to  Handle Core Data with swift

The first step is to create a managed object model, which describes the way Core Data represents data on disk.

By default, Core Data uses a SQLite database as the persistent store, so you can think of the Data Model as the database schema.

  • An entity is a class definition in Core Data. The classic example is an Employee or a Company. In a relational database, an entity corresponds to a table.
  • An attribute is a piece of information attached to a particular entity. For example, an Employee entity could have attributes for the employee’s name, position and salary. In a database, an attribute corresponds to a particular field in a table.
  • A relationship is a link between multiple entities. In Core Data, relationships between two entities are called to-one relationships, while those between one and many entities are called to-many relationships. For example, a Manager can have a to-many relationship with a set of employees, whereas an individual Employee will usually have a to-one relationship with his manager.

Remember, in an interview setting, it’s important not only to provide accurate answers but also to demonstrate a good understanding of how Core Data works, when and why to use it, and its integration with Swift and iOS development.