Showing the first 50 of 85 results for "core data"
SwiftData is Apple's modern take on local persistence. It has a cleaner syntax, tighter SwiftUI integration, and less boilerplate. Core Data is the two-decade-old workhorse. For Hive Notes and its 15-entity data model, I needed reliability over novelty. Sometimes boring technology is exactly what you need.
in Core Data
8:34
We successfully seeded the Core Data persistent store with hard-coded seed data in the previous episode. While the implementation works fine, it isn't perfect. Seeding the persistent store takes place on the main thread. We invoke the seed() method in the viewDidLoad() method of the NotesViewController class and we insert the managed objects into the main managed object context of the Core Data manager.
in Core Data
9:52
Seeding a Core Data persistent store with hard-coded seed data is fast and easy. The application we'll be seeding with data in this episode is Notes, the application we build in Core Data Fundamentals. Download the starter project of this episode if you'd like to follow along.
in Core Data
8:43
Developers often complain that Core Data has an arcane syntax and complicated API. "It's tedious to work with Core Data." seems to be the general consensus. It's true that Core Data used to be difficult to use and the framework's syntax wasn't as elegant as it could be. That's something of the past, though. The more Core Data matures, the more I enjoy and appreciate the framework. First impressions are difficult to change and it's therefore unsurprising that developers often fall back to third party libraries. Using a third party library to interact with a first party framework isn't something I recommend. Many of us find fetching records from a persistent store to be clunky and tedious. Is that true? In this series, I'd like to show you how easy and elegant fetching records from a persistent store can be.
in Core Data
5:06
It's time to shift gears and focus on the Category class. This shouldn't be difficult since you already know how to write unit tests for a Core Data model and we laid the foundation when we implemented the unit tests for the Note class. Pause the episode for a moment and give it a try.
in Core Data
5:59
It's time to write the first unit test for the Note class. The first unit test we write tests the updatedAtAsDate computed property of the Note class. Remember that we only unit test the behavior we add to the Note class. We name the unit test testUpdatedAtAsDate()
in Core Data
7:02
Remember from Core Data Fundamentals that we need a managed object context to instantiate a managed object. To freshen up your memory, this is what it takes to create a note.
in Core Data
4:11
In this series, I show you how to unit test Core Data models. Before we start, though, I'd like to challenge you. How would you unit test a Core Data model? Pause the video for a moment and try to come up with a strategy. Remember what we covered in Core Data Fundamentals. Which ingredients do we need to create an NSManagedObject instance?
in Core Data
4:27
My hope is that this series has taught you that Core Data isn't as difficult as many developers believe it to be. Core Data isn't complex once you understand how the various pieces of the framework fit together.
in Core Data
8:01
In this episode, I'd like to discuss a concept that often confuses developers new to Core Data, faulting. Before I explain what faulting is, I want to show it to you.
in Core Data
10:21
The CoreDataManager class is in charge of the Core Data stack of the application. It encapsulates the Core Data stack and only exposes the main managed object context to the rest of the application.
in Core Data
1:10
Because we updated the CoreDataManager class in the previous episode, we need to make a few changes in the project.
in Core Data
7:13
It's time to refactor the CoreDataManager class. Let me walk you through the changes we need to make. Don't worry, though, most of the implementation of the CoreDataManager class remains unchanged.
in Core Data
6:43
An application that grows and gains features also gains new requirements. The data model, for example, grows and changes. Core Data handles changes pretty well as long as you play by the rules of the framework.
in Core Data
6:13
To update the table view, we listened for notifications sent by the managed object context of the Core Data manager. This is a perfectly fine solution. But it can be messy to sift through the managed objects contained in the userInfo dictionary of the notification. In a complex Core Data application, the NSManagedObjectContextObjectsDidChange notification is sent very frequently. It includes every change of every managed object, even the ones we may not be interested in. We need to make sure we only respond to the changes of the managed objects we are interested in.
in Core Data
7:03
The application now supports creating, reading, updating, and deleting notes. And this works fine. But Core Data has another trick up its sleeve.
in Core Data
8:44
Core Data records are represented by the NSManagedObject class, a key class of the framework. In this episode, you learn how to create a managed object, what classes are involved, and how a managed object is saved to a persistent store.
in Core Data
6:41
Core Data is much more than a database and this becomes clear when you start working with relationships. Relationships in Core Data are powerful because the framework does a lot of the heavy lifting for you.
in Core Data
6:36
Core Data is great at managing relationships. In this episode, we continue our exploration of the data model by taking a close look at relationships.
in Core Data
5:39
The data model is a key component of the Core Data stack and an integral part of a Core Data application. In this episode, we explore the data model and learn about entities and attributes.
in Core Data
3:13
I'm not going to lie. I don't like singletons. Singletons are fine if they're used correctly, but I don't like singletons for convenience. They almost always lead to problems down the line. This means that the Core Data manager isn't going to be a singleton.
in Core Data
8:31
It's time to write some code. Had we checked the Use Core Data checkbox during the setup of the project, Xcode would have put the code for the Core Data stack in the application delegate. This is something I don't like and we won't be cluttering the application delegate with the setup of the Core Data stack.
in Core Data
1:06
Before we set up the Core Data stack, we need to create the project for Notes. Open Xcode and create a new project based on the Single View App template.
in Core Data
6:46
Earlier in this series, you learned what Core Data is and isn't. This episode zooms in on the building blocks of the Core Data framework.
in Core Data
1:49
Notes is a simple application for iOS that manages a list of notes. It's a fine case study to teach you the fundamentals of the Core Data framework. In this episode, I'd like to show you what Notes is capable of.
in Core Data
5:08
Developers new to Core Data usually don't take the time to learn the framework. Not knowing what Core Data is, makes it hard and frustrating to wrap your head around the ins and outs of the framework. I'd like to start by spending a few minutes exploring the nature of Core Data and, more important, explain to you what Core Data is and isn't.
in Core Data
3:08
Welcome to Core Data Fundamentals. In this series, you'll learn the ins and outs of Apple's popular Core Data framework. Even though we'll be building an iOS application, the Core Data framework is available on iOS, tvOS, macOS, and watchOS, and the contents of this series apply to each of these platforms.
in Core Data
Developers often complain that Core Data has an arcane syntax and a complicated API. "It's tedious to work with Core Data." seems to be the general consensus. It's true that Core Data used to be difficult to use and the framework's syntax wasn't as elegant as it could be. That's something of the past, though. The more Core Data matures, the more I enjoy and appreciate the framework.
in Core Data
Core Data is a fantastic framework and I love using it. I agree that Core Data has a learning curve, but isn't this true for many other frameworks? Because of Core Data's learning curve, developers often turn to third party libraries that make working with the framework easier.
in Core Data
The types you can store in a Core Data persistent store are limited and it probably won't surprise you that UIColor objects are not supported out of the box.
in Core Data
In Core Data Beyond the Basics, we work with an application that manages clients and their invoices. I named the application Invoices. What's in a name? The application is similar to, for example, the mobile application of FreshBooks.
in Core Data
If you're reading this, then I assume you are new to Core Data. You may have heard about Core Data and you'd like to find out whether it's a good fit for you or the project you're working on. If this description fits you, then take a seat. This Core Data tutorial teaches you everything you need to know to better understand what Core Data is and isn't.
in Core Data
In the previous tutorial, we discussed Core Data in the light of concurrency. I hope that lesson has taught you that Core Data and concurrency can go hand in hand. As long as you remember the basic rules we discussed, you should be fine.
in Core Data
Up to now, we've used a single managed object context, which we created in the CoreDataManager class. This works fine, but there will be times when one managed object context won't suffice.
in Core Data
The NSFetchedResultsController class isn't an essential component of a Core Data application, but it makes working with collections of managed objects much easier. This tutorial introduces you to the, almost magical, NSFetchedResultsController class.
in Core Data
An application that grows and gains features also gains new requirements. The data model, for example, grows and changes. Core Data handles changes pretty well as long as you play by the rules of the framework.
in Core Data
The final piece of the CRUD puzzle covers deleting records from a persistent store. I can assure you that deleting records is no rocket science. We also take a closer look at the NSFetchRequest class. In the previous tutorial, we used this class to fetch the records of an entity. But NSFetchRequest has a lot more to offer.
in Core Data
In the previous tutorial, we created a list record and pushed it to the persistent store by saving its managed object context. The persistent store coordinator handled the nitty-gritty details of inserting the list record into the persistent store. This tutorial focuses on reading and updating records.
in Core Data
In this tutorial, we take a look at the NSManagedObject class, a key class of the Core Data framework. You learn how to create a managed object, what classes are involved, and how a managed object is saved to a persistent store.
in Core Data
Core Data is great at managing relationships. In this tutorial, we explore the data model and take a close look at relationships.
in Core Data
The data model is a key component of the Core Data stack and an integral part of every Core Data application. In this tutorial, we explore the data model and learn about entities and attributes.
in Core Data
In the previous tutorial, we set up a Core Data stack using the NSPersistentContainer class. While this is convenient, it teaches you very little about the Core Data stack and how to set one up from scratch. In this lesson, we create a Core Data stack without relying on Xcode's Core Data template.
in Core Data
In the previous tutorial, you learned about the Core Data stack and the classes involved. In this tutorial, we take a close look at Xcode's template for Core Data applications.
in Core Data
If you dipped your toe in iOS or macOS development, then you've probably heard about Core Data. Core Data is Apple's framework for managing and persisting an object graph. It was introduced in 2005, alongside the release of Mac OS X Tiger. On iOS, the framework has been available since iPhone OS 3.0.
in Core Data
NSManagedObject is the class you interact with most when you work with Core Data. The class may appear as a glorified dictionary, but it is much more than that. In this tutorial, I show you three features of the NSManagedObject class you may not know about.
in Core Data
Core Data received an important update during this year's WWDC. We already explored the addition the of the NSPersistentContainer class and Xcode's improved support for Core Data. But there are several more subtle additions and enhancements worth exploring, such as the NSPersistentStoreDescription class. That is the focus of this tutorial.
in Core Data
What is the difference between Core Data and SQLite? Even though it's a common question, it is the wrong one to ask. Comparing Core Data and SQLite is like trying to compare apples and oranges. But why is that?
in Core Data
Earlier this month, I wrote about Core Data faults. Faulting is a key concept of the Core Data framework. It is because of faulting that Core Data is as performant as it is and it ensures Core Data's memory footprint remains at an acceptable level.
in Core Data
Developers familiar with Core Data don't consider the framework difficult or hard to work with. If you respect the rules of the framework, Core Data won't surprise you. But that is often the problem. Developers make mistakes because they violate a rule they don't know about. In this article, I discuss three common mistakes developers make working with Core Data.
in Core Data
Core Data is one of the most misunderstood frameworks available on iOS, tvOS, macOS, and watchOS. And that is unfortunate because it is a fantastic piece of software engineering. But why is it misunderstood?
in Core Data