Tag: NSFetchedResultsController

NSFetchedResultsController wrapper for SwiftUI view models

Post author By Toomas Vahter
Post date April 3, 2023

Although SwiftUI framework contains a @FetchRequest property wrapper, it is not possible to use it outside of SwiftUI views because it relies on accessing the managed object context from the view environment. While working on an CoreData based app which uses view models a lot within SwiftUI views, I ended up creating a wrapper class for making it easier to use NSFetchedResultsController. The wrapper class is named FetchedResultList and what it does internally is creating a NSFetchedResultsController instance, handling its delegate methods, and notifying about data changes through closures. Here is an example of a view model using the wrapper.

	@MainActor final class ViewModel: ObservableObject {
	private let list: FetchedResultList<Fruit>

	init(context: NSManagedObjectContext = PersistenceController.shared.container.viewContext) {
	list = FetchedResultList(context: context,
	sortDescriptors: [
	NSSortDescriptor(keyPath: \Fruit.name, ascending: true)
	])
	list.willChange = { [weak self] in self?.objectWillChange.send() }
	}

	var fruits: [Fruit] {
	list.items
	}

	@Published var searchText: String = "" {
	didSet {
	if searchText.isEmpty {
	list.predicate = nil
	}
	else {
	list.predicate = NSPredicate(format: "name contains[cd] %@", searchText)
	}
	}
	}
	}

view raw Fruits.swift hosted with ❤ by GitHub

The view model conforms to ObservableObject protocol and FetchedResultList provides a willChange closure which gets called when NSFetchedResultsController’s will change delegate is called. Calling the objectWillChange publisher will signal the SwiftUI view about the data change and the view gets re-rendered. The wrapper also supports updating predicate or sort descriptors dynamically. Here, we can see how setting a searchableText property from the view will update the predicate of the wrapper class. The SwiftUI view which uses the view model looks like this:

	struct FruitList: View {
	@StateObject var viewModel = ViewModel()

	var body: some View {
	NavigationStack {
	List(viewModel.fruits) { item in
	NavigationLink(item.name) {
	Text(verbatim: "Detail view for \(item.name)")
	}
	}
	.navigationTitle("Fruits")
	.searchable(text: $viewModel.searchText)
	}
	}
	}

view raw Fruits.swift hosted with ❤ by GitHub

Let’s take a look at how the wrapper class is implemented. The core logic around the wrapper is creating an instance of NSFetchedResultsController, allowing to reconfigure it dynamically, handling its delegate, and notifying changes through closures. Using closures instead of conforming to ObservableObject is a conscious choice since the main use case is using the wrapper class in view models or in other controllers, and it means that propagating the data change to a SwiftUI view needs to be done manually. It is shorter to call view model’s objectWillChange in a closure than republishing wrapper’s objectWillChange to view model’s objectWillChange. Moreover, it would make more sense to use SwiftUI provided property wrapper instead of this wrapper if we would want to handle CoreData fetching in the SwiftUI view’s implementation.

	@MainActor final class FetchedResultList<Result: NSManagedObject> {
	private let fetchedResultsController: NSFetchedResultsController<Result>
	private let observer: FetchedResultsObserver<Result>

	init(context: NSManagedObjectContext, filter: NSPredicate? = nil, sortDescriptors: [NSSortDescriptor]) {
	let request = NSFetchRequest<Result>(entityName: Result.entity().name ?? "<not set>")
	request.predicate = filter
	request.sortDescriptors = sortDescriptors.isEmpty ? nil : sortDescriptors
	fetchedResultsController = NSFetchedResultsController(fetchRequest: request, managedObjectContext: context, sectionNameKeyPath: nil, cacheName: nil)
	observer = FetchedResultsObserver(controller: fetchedResultsController)
	observer.willChange = { [unowned self] in self.willChange?() }
	observer.didChange = { [unowned self] in self.didChange?() }
	refresh()
	}

	private func refresh() {
	do {
	try fetchedResultsController.performFetch()
	}
	catch {
	Logger().error("Failed to load results")
	}
	}

	var items: [Result] {
	fetchedResultsController.fetchedObjects ?? []
	}

	var predicate: NSPredicate? {
	get {
	fetchedResultsController.fetchRequest.predicate
	}
	set {
	fetchedResultsController.fetchRequest.predicate = newValue
	refresh()
	}
	}

	var sortDescriptors: [NSSortDescriptor] {
	get {
	fetchedResultsController.fetchRequest.sortDescriptors ?? []
	}
	set {
	fetchedResultsController.fetchRequest.sortDescriptors = newValue.isEmpty ? nil : newValue
	refresh()
	}
	}

	var willChange: (() -> Void)?
	var didChange: (() -> Void)?
	}

view raw FetchedResultList.swift hosted with ❤ by GitHub

The wrapper class uses private FetchedResultsObserver class which must derive from NSObject because it implements NSFetchedResultsControllerDelegate methods. This approach allows keeping the FetchedResultList class a pure Swift class and not a NSObject subclass which I like to avoid in SwiftUI apps (just a personal preference).

	private final class FetchedResultsObserver<Result: NSManagedObject>: NSObject, NSFetchedResultsControllerDelegate {
	var willChange: () -> Void = {}
	var didChange: () -> Void = {}

	init(controller: NSFetchedResultsController<Result>) {
	super.init()
	controller.delegate = self
	}

	func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
	willChange()
	}

	func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
	didChange()
	}
	}

view raw FetchedResultsObserver.swift hosted with ❤ by GitHub

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.

Support me on Patreon

Donate with Paypal

Buy me a coffee

Tags CoreData, FetchedResultList, iOS, NSFetchedResultsController, Swift, SwiftUI

Combine CoreData Foundation Generics iOS Swift SwiftUI Xcode

Using CoreData with SwiftUI

Post author By Toomas Vahter
Post date January 19, 2020
1 Comment on Using CoreData with SwiftUI

CoreData is Apple’s object graph and persistence framework. It provides data sources for synchronising data with view. Let’s take a look on how to use those data sources in SwiftUI views. Starting with NSFetchedResultsController what is used for list and collection views, after that observing NSManagedObject directly from SwiftUI view and lastly subscribing to managed object context notifications.

NSFetchedResultsController

NSFetchedResultsController is used for providing data in table and collection views. It supports sorting and filtering data and arranging data into sections. We can use delegate for getting change callbacks. NSFetchedResultsControllerDelegate contains several methods:

	// Diffable data source (new in iOS 13)
	optional func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChangeContentWith snapshot: NSDiffableDataSourceSnapshot)
	optional func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChangeContentWith diff: CollectionDifference<NSManagedObjectID>)

	// Manually updating table view and collection view
	optional func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange anObject: Any, at indexPath: IndexPath?, for type: NSFetchedResultsChangeType, newIndexPath: IndexPath?)
	optional func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange sectionInfo: NSFetchedResultsSectionInfo, atSectionIndex sectionIndex: Int, for type: NSFetchedResultsChangeType)
	optional func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>)
	optional func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>)

view raw DataSources.swift hosted with ❤ by GitHub

In SwiftUI we are not going to directly manipulate views. Only what we need to do is letting SwiftUI view know that data is about to change. Let’s take a look on simple app with list of items stored by CoreData. Data is represented by ColorItem where only stored value is hex string of the color (e.g. #AA22BB).

	final class ColorItem: NSManagedObject {
	@NSManaged var hex: String
	}

view raw ColorItem.swift hosted with ❤ by GitHub

ColorItems are managed by ContentView’s view model. View model creates NSFetchedResultsController, performs fetch and provides array of fetched ColorItems to the SwiftUI’s List. In addition, view model is delegate of the NSFetchedResultsController (requires view model to be NSObject subclass). As view model is ObservableObject, we can very easily let SwiftUI view know that it should refresh. We need to do two things: firstly, implementing controllerWillChangeContent delegate method and calling send() on objectWillChange publisher. Secondly, view model property must use @ObservedObject property wrapper in SwiftUI view. Result is that SwiftUI view subscribes to objectWillChange publisher and refreshes whenever publisher emits an event.

	extension ContentView {
	final class ViewModel: NSObject, NSFetchedResultsControllerDelegate, ObservableObject {
	private let colorController: NSFetchedResultsController<ColorItem>

	init(managedObjectContext: NSManagedObjectContext) {
	let sortDescriptors = [NSSortDescriptor(keyPath: \ColorItem.hex, ascending: true)]
	colorController = ColorItem.resultsController(context: managedObjectContext, sortDescriptors: sortDescriptors)
	super.init()
	colorController.delegate = self
	try? colorController.performFetch()
	}

	func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
	objectWillChange.send()
	}

	var colors: [ColorItem] {
	return colorController.fetchedObjects ?? []
	}
	}
	}

	extension ColorItem {
	static func resultsController(context: NSManagedObjectContext, sortDescriptors: [NSSortDescriptor] = []) -> NSFetchedResultsController<ColorItem> {
	let request = NSFetchRequest<ColorItem>(entityName: "ColorItem")
	request.sortDescriptors = sortDescriptors.isEmpty ? nil : sortDescriptors
	return NSFetchedResultsController(fetchRequest: request, managedObjectContext: context, sectionNameKeyPath: nil, cacheName: nil)
	}
	}

view raw ViewModelFetchedResults.swift hosted with ❤ by GitHub

And finally let’s see the ContentView implementation. NSManagedObject has objectID property what we can use in List for identifying every ColorItem. Cell is custom view what we’ll take a look at next.

	struct ContentView: View {
	@ObservedObject var viewModel: ViewModel

	var body: some View {
	NavigationView {
	VStack {
	List(viewModel.colors, id: \.objectID) { (colorItem) in
	Cell(colorItem: colorItem)
	}
	}.navigationBarTitle("Colors")
	}
	}
	}

view raw ContentViewFetchedResults.swift hosted with ❤ by GitHub

NSManagedObject

NSManagedObject implements ObservableObject protocol and therefore it is possible to use it together with @ObservedObject property wrapper and getting SwiftUI view refreshed automatically when any of the ColorItem properties change. NSFetchedResultsController required a little bit of code for setting up delegate but that is not the case with NSManagedObject.

	struct Cell: View {
	@ObservedObject var colorItem: ColorItem

	var body: some View {
	HStack {
	Text(verbatim: colorItem.hex)
	Spacer()
	Rectangle().foregroundColor(Color(colorItem.uiColor)).frame(minWidth: 50, maxWidth: 50)
	}
	}
	}

view raw Cell.swift hosted with ❤ by GitHub

In addition, if there are cases where we would like to observe specific property, then Combine provides publisher for key path. Because NSManagedObject supports key-value observing we can use the publisher and subscribe to individual property changes.

	let cancellable = color.publisher(for: \.hex).sink { (string) in
	print(string)
	}

view raw KVOPublisherSink.swift hosted with ❤ by GitHub

Subscribing to CoreData notifications

When we need to observe changes in persistent store we can observe notifications sent by the framework. As NotificationCenter supports publishers, we can subscribe to it, unpack data from notification and do something with the data. For making this easier we can introduce a separate type. It will unpack the user info dictionary and filter by type. This allows to easily observe, for example, ColorItem insertions. Or, if we would like to receive every possible change, we can specify NSManagedObject as the generic type.

	private var cancellables = [AnyCancellable]()

	let cancellable = NotificationCenter.default.publisher(for: .NSManagedObjectContextObjectsDidChange, object: managedObjectContext)
	.compactMap({ ManagedObjectContextChanges<ColorItem>(notification: $0) }).sink { (changes) in
	print(changes)
	}
	cancellables.append(cancellable)

	struct ManagedObjectContextChanges<T: NSManagedObject> {
	let inserted: Set<T>
	let deleted: Set<T>
	let updated: Set<T>

	init?(notification: Notification) {
	let unpack: (String) -> Set<T> = { key in
	let managedObjects = (notification.userInfo?[key] as? Set<NSManagedObject>) ?? []
	return Set(managedObjects.compactMap({ $0 as? T }))
	}
	deleted = unpack(NSDeletedObjectsKey)
	inserted = unpack(NSInsertedObjectsKey)
	updated = unpack(NSUpdatedObjectsKey).union(unpack(NSRefreshedObjectsKey))
	if deleted.isEmpty, inserted.isEmpty, updated.isEmpty {
	return nil
	}
	}
	}

view raw ManagedObjectContextChanges.swift hosted with ❤ by GitHub

Summary

We took a look at how to use NSFetchedResultsController and NSManagedObject in SwiftUI views. We saw that integrating NSFetchedResultsController requires only a little bit of code and using NSManagedObject even less. In addition, we looked at subscribing to CoreData notifications and unpacking notification payload.

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.

Example project

CoreDataCombineSwiftUI (Xcode 11.3)

Support me on Patreon

Donate with Paypal

Buy me a coffee

Tags AnyCancellable, CoreData, List, NSDeletedObjectsKey, NSFetchedResultsController, NSInsertedObjectsKey, NSManagedObject, NSManagedObjectContext, NSObject, NSRefreshedObjectsKey, NSUpdatedObjectsKey, objectWillChange, ObservableObject, ObservedObject, persistence, persistent, SwiftUI

CoreData Swift

Storing data with CoreData

Post author By Toomas Vahter
Post date July 6, 2018
No Comments on Storing data with CoreData

CoreData is a framework for managing object graphs and storing them on disk. It is much more than just offering a persistent storage, therefore the rich API it provides, is meant to be used app-wide. In this blog post we’ll look into how to initialise CoreData storage, store some data in it and fetching it.

Core data model

First step is to add a Core Data model which will describe model objects, their relationships and properties. In Xcode we’ll go to File -> New -> File… and then select Data Model.

We are going to continue working on sample app named Planets (from previous post). It needs an entity named Planet which has 3 properties: name, url and position (defines sort order in the app). By default Core Data will autogenerate a model object for our entity Planet we just defined. Therefore all we need to do is creating an entity and adding three properties to the entity.

Initialising CoreData stack

The simplest way for initialising Core Data stack is to use NSPersistentContainer and initialising it with a name of the Core Data model file we just created in the previous step. After creating the container, it needs to be loaded which will read the Core Data model file and sets up a persistent store.

	convenience init(name: String)
	func loadPersistentStores(completionHandler block: @escaping (NSPersistentStoreDescription, Error?) -> Void)

view raw NSPersistentContainer.swift hosted with ❤ by GitHub

In the sample app we are going to use subclass of NSPersistentContainer named CoreDataStore which contains extra methods used in a moment.

Storing data

Adding data contains of two steps: making changes in NSManagedObjectContext and then saving it. NSManagedObjectContext is a scratch pad where to make changes in your object graph. All the changes will be stored in memory until save is called.
For adding a new entity we will use a method in our CoreDataStore.

	func insertNewEntity(named name: String) -> NSManagedObject {
	return NSEntityDescription.insertNewObject(forEntityName: name, into: viewContext)
	}

view raw CoreDataStore.swift hosted with ❤ by GitHub

This will add a new empty entity to managed object context. After that, we’ll fill properties with appropriate values and then call save.

	func tryStoringDefaultPlanets() {
	// dataStore is an instance of NSPersistentContainer subclass CoreDataStore.
	guard dataStore.count(for: "Planet") == 0 else { return }

	// Insert new entities into managed object context.
	let names = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
	let paths = ["https://en.wikipedia.org/wiki/Mercury_(planet)", "https://en.wikipedia.org/wiki/Venus", "https://en.wikipedia.org/wiki/Earth", "https://en.wikipedia.org/wiki/Mars", "https://en.wikipedia.org/wiki/Jupiter", "https://en.wikipedia.org/wiki/Saturn", "https://en.wikipedia.org/wiki/Uranus", "https://en.wikipedia.org/wiki/Neptune"]
	zip(names, paths).enumerated().forEach { (offset, element) in
	guard let planet = dataStore.insertNewEntity(named: "Planet") as? Planet else { return }
	planet.position = Int64(offset)
	planet.name = element.0
	planet.url = URL(string: element.1)
	}
	// Save changes in the managed object context what at the moment contains added Planets.
	dataStore.save()
	}

view raw PlanetManager.swift hosted with ❤ by GitHub

Fetching data

In our sample app, there is a simple table view displaying a list of planets. For displaying data efficiently, Core Data has a class NSFetchedResultsController. It uses NSFetchRequest objects for fetching, sorting and filtering results. Our class CoreDataStore has a convenience method for creating fetched results controller for any type of entities and PlanetManager has a getter for returning controller for Planet entities.

	final class CoreDataStore: NSPersistentContainer {
	func fetchedResultsController(named name: String, sortDescriptors: [NSSortDescriptor], predicate: NSPredicate? = nil, sectionNameKeyPath: String? = nil) -> NSFetchedResultsController<NSFetchRequestResult> {
	let request = NSFetchRequest<NSFetchRequestResult>(entityName: name)
	if let predicate = predicate {
	request.predicate = predicate
	}
	request.sortDescriptors = sortDescriptors.isEmpty ? nil : sortDescriptors
	return NSFetchedResultsController(fetchRequest: request, managedObjectContext: viewContext, sectionNameKeyPath: sectionNameKeyPath, cacheName: nil)
	}
	}

	final class PlanetManager {
	lazy var planetsController: NSFetchedResultsController<Planet> = {
	let descriptors = [NSSortDescriptor(key: "position", ascending: true)]
	return dataStore.fetchedResultsController(named: "Planet", sortDescriptors: descriptors) as! NSFetchedResultsController<Planet>
	}()
	}

view raw FetchingData.swift hosted with ❤ by GitHub

Let’s see how to hook up fetched results controller to table view controller. Before fetched controller is used for fetching data, it needs to perform a fetch. For a simple list view it is pretty straight-forward: getting count and fetching an object for index path.

	private func fetchPlanets() {
	do {
	try planetsController.performFetch()
	tableView.reloadData()
	}
	catch {
	NSLog("Fetching failed with error \(error as NSError).")
	}
	}

	override func numberOfSections(in tableView: UITableView) -> Int {
	return 1
	}

	override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
	return planetsController.sections?[0].numberOfObjects ?? 0
	}

	override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
	let cell = tableView.dequeueReusableCell(withIdentifier: "PlanetCellIdentifier", for: indexPath)
	cell.accessoryType = .disclosureIndicator
	cell.textLabel?.text = planetsController.object(at: indexPath).name
	return cell
	}

	override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
	scenePresenter?.presentDetailedInfo(for: planetsController.object(at: indexPath))
	}

view raw PlanetTableViewController.swift hosted with ❤ by GitHub

Summary

In this blog post we looked into how to initialise Core Data stack with NSPersistentContainer, storing some data in it with NSManagedObjectContext and fetching results with NSFetchedResultsController. It is the most basic usage of CoreData and covers a tiny bit what Core Data can do. Apple has a pretty good documentation what covers much more compared to what was described here (see links to Core Data classes in the previous sections).

Example

Planets (GitHub)

References

CoreData (Apple)

Tags NSFetchedResultsController, NSManagedObjectContext