Saving And Fetching Data In CoreData

import Foundation
import CoreData
public class College: NSManagedObject {
}

College+CoreDataProperties.swift

in this file, we have all the properties that we have created for the college entity and a function fetch request() whose return type is NSFetchRequest which is required to fetch data from core data.

import Foundation
import CoreData
extension College {
    @nonobjc public class func fetchRequest() -> NSFetchRequest<College> {
        return NSFetchRequest<College>(entityName: "College")
    }
    @NSManaged public var name: String?
    @NSManaged public var city: String?
    @NSManaged public var address: String?
    @NSManaged public var university: String?
}

When we write code we have to take care of readability, that's why we will create a swift file DatabaseHelper which will contain save and fetch function that we will use when we will have to save or fetch data from CoreData.

Saving data into CoreData

func save(object: [String: String]) {
    let context = (UIApplication.shared.delegate as!AppDelegate).persistentContainer.viewContext
    let college = NSEntityDescription.insertNewObject(forEntityName: "College", into: context) as!College
    college.name = object["name"]
    college.city = object["city"]
    college.address = object["address"]
    college.university = object["university"]
    do {
        try context.save()
        print("successfully saved")
    } catch {
        print("Could not save")
    }
}

In save function we are passing a dictionary that contains name, city, address, and university that we want to save into CoreData. When we added CoreData to our project then a stack of CoreData methods already created in AppDelegate File. There is a persistent container that will be responsible for all the operations that we will perform into CoreData like save, fetch, delete and update. There is another function created in AppDelegate SaveContext which is used to save our data into CoreData.

Now we will create context of that persistent container that contains ViewContext method where we will save our data, here we create a variable college that stores the description of entity College and we will insert new object into context that will save our data, then we perform context.save() method that will create exception so we use try catch method to handle that exception. We have successfully saved our college data into CoreData.

Fetching Data From CoreData

func fetch() - > [College] {
    var collegeData = [College]()
    do {
        collegeData =
            try context.fetch(College.fetchRequest())
    } catch {
        print("couldnt fetch")
    }
    return collegeData
}

We saved our data into CoreData now we have to fetch all the data stored in CoreData, for this we have already written method in College+CoreDataProperties.swift file fetchRequest. We have created a function fetch() whose return type is array of College(Entity). For fetching the data we just write context.fetch and pass fetchRequest that will generate an exception so we handle it by writing try catch, so we fetched our all the data from CoreData.

Key points about CoreData

• CoreData is an important method to store our data locally. We can fetch our saved data even after terminating the app, according to apple developer's documentation it reduced 50-70 % of your code.
• Managed Object model contains entity, attributes and relations
• Entity in CoreData is an instance of NSEntityDescription which contains information like attributes.
• Attributes are all information attached with an entity.
• NSManagedObjectContext is reponsible to save() and fetch() data from CoreData

Thanks for reading this article.