Core Data Overview

What is Core Data?

The Core Data framework provides generalized and automated solutions to common tasks associated with object life-cycle and object graph management, including persistence. Its features include:

• Built-in management of undo and redo beyond basic text editing

• Automatic validation of property values to ensure that individual values lie within acceptable ranges and that combinations of values make sense

• Change propagation, including maintaining the consistency of relationships among objects

• Grouping, filtering, and organizing data in memory and in the user interface

• Automatic support for storing objects in external data repositories

• Optional integration with Cocoa bindings to support automatic user interface synchronization

Prerequisites

Core Data is not an entry-level technology. It leverages many other Cocoa technologies and design patterns. You must understand these technologies and patterns before you can use Core Data effectively:

• Cocoa fundamentals

  Objective-C, memory management, notifications, and delegation.

• Data modeling and the model-view-controller design pattern

  The terminology used by Core Data is defined and explained in the “Object Modeling” in Cocoa Fundamentals Guide section of Cocoa Design Patterns. You should also ensure you understand the model-view-controller design pattern, and other related design patterns, described in the same document. Many of the ideas and patterns upon which Core Data is built derive from the relational model of database design—it is extremely helpful to have a basic understanding of this subject (see, for example, Wikipedia (Relational_model)).

• Key-value technologies

  Key-value coding and key-value observing underpin Core Data. You should understand the concepts described in Key-Value Coding Programming Guide and Key-Value Observing Programming Guide.

One of the persistent stores provided by Core Data is based upon SQLite. If you use this store, it is useful—although not essential—to have at least a superficial understanding the SQL language. Documentation for SQLite is available from the SQLite project web site. There are numerous resources that describe the SQL language, for example Wikipedia (SQL).

Path to Success

The Core Data Programming Guide is primarily a reference volume. You should not simply try to read it straight through to understand Core Data.

To learn about Core Data, you should typically follow this path:

1. Start by reading the overview in Core Data Basics (in Core Data Programming Guide).

2. Work through the Core Data Utility Tutorial.

   This will give you an appreciation of the different components of the framework, without the distraction of a user interface.

3. Work through the tutorial described in Creating a Managed Object Model with Xcode.

   This introduces the major user interface elements of, and teaches you how to use, the Xcode modeling tool. In particlular, it shows you how to establish relationships between two entities.

When specific areas need greater explanation, refer to the Core Data Programming Guide.

Do not attempt the NSPersistentDocument Core Data Tutorial unless or until you also understand Cocoa bindings.

Next Steps

After you’ve worked through the introductory materials, try creating more complex applications (using, for example, two related entities). The Core Data Programming Guide will be increasingly useful as you continue your exploration, as will Model Object Implementation Guide and Predicate Programming Guide. Core Data Snippets may be helpful as you write more code.

As you progress, it is important to bear in mind that Core Data objects are still just objects, and have little influence on the user interface parts of your application simply by virtue of being Core Data objects. (In fact, the reverse is true—you may find that your user interface affects the way you structure your data.) You should practice creating Core Data applications using traditional Cocoa techniques such as target-action and delegation just as you would in a non-Core Data application.

Core Data and Cocoa Bindings

Cocoa bindings is a technology you can use to easily keep user interface elements synchronized with the data values they display. For more about Cocoa bindings, see Cocoa Bindings Programming Topics—in particular What Are Cocoa Bindings?. Cocoa bindings and Core Data are orthogonal—where Core Data is used to manage an object graph of model objects, Cocoa bindings is used to synchronize the values in an object graph with elements in a user interface. Neither technology depends on the other.

Although Cocoa bindings and Core Data are independent and address different issues, both provide abstraction layers that—while individually they are reasonably straightforward to grasp—can be challenging to master simultaneously. You should choose one to learn first, then turn to the other. Once you are comfortable with bindings, watch the ADC video Core Data Tutorial and work through the NSPersistentDocument Core Data Tutorial—these bring both technologies together.

There are a few isolated cases where Core Data and bindings affect one another, which are evident from their respective APIs (for example, controllers have a binding for a managed object context, and an attribute for an entity name). These points of integration should be investigated first when problems arise (see Core Data and Cocoa Bindings in Core Data Programming Guide for more information).

Core Data in Depth

There are several documents that describe particular aspects of Core Data in greater depth than in the Programming Guide. You should use these documents only when you have a firm understanding of how Core Data works, and then only if and when you need to:

• Core Data Model Versioning and Data Migration Programming Guide

  Read this document to learn how to support versioning.

• Atomic Store Programming Topics

  Read this document to understand how to create your own type of persistent store.

• NSPersistentDocument Core Data Tutorial

  Follow this tutorial to understand how to use the Application Kit’s NSDocument subclass to create a document-based application that uses Core Data. Do not attempt this tutorial unless or until you also understand Cocoa bindings.