Core Data by Tutorials (Aaron Douglas, Matthew Morey and Pietro Rea)（Z-Library）

【One-Line Pitch】 A hands-on, project-based guide for iOS developers who want to master Core Data, Apple’s object graph and persistence framework, by building real apps from scratch rather than just reading API docs. If you’re comfortable with Swift and Xcode but find Core Data intimidating, this book walks you through everything from your first model to advanced performance tuning. 【Book Arc】 - **Opening (~0%–10%)**: Introduces the Core Data stack (managed object context, persistent store coordinator, and managed object model) and gets you building your first simple app with a basic data model. This stage solves the “where do I even start?” problem by showing the minimal setup needed to persist data. - **Early (~10%–30%)**: Covers the NSManagedObject subclassing, fetching data with NSFetchRequest, and sorting/filtering results using predicates. You learn how to read data back out of the store efficiently and how to structure your model relationships (one-to-one, one-to-many, many-to-many). - **Middle (~30%–60%)**: Dives into more complex topics like data validation, undo management, and working with multiple managed object contexts. This is where the book shifts from “make it work” to “make it robust,” addressing common pitfalls like context concurrency and merge conflicts. - **Late (~60%–85%)**: Focuses on performance and advanced features: batch updates, faulting, prefetching, and using NSFetchedResultsController to drive table views and collection views. You also get into versioning and lightweight migration, which is critical for shipping apps that evolve over time. - **Ending (~85%–100%)**: Wraps up with practical, real-world scenarios like syncing with iCloud (CloudKit integration), storing non-standard data types (e.g., images or transformable attributes), and debugging tools like Core Data’s SQLite debug output. The final chapters tie everything together with a polished sample app that demonstrates the full lifecycle of a Core Data project. 【Key Takeaways】 - **The Core Data stack is the backbone of everything** (Opening): understanding the three core components—NSManagedObjectModel, NSPersistentStoreCoordinator, and NSManagedObjectContext—is non-negotiable. Get this mental model right and the rest of the framework feels logical; get it wrong and every tutorial will confuse you. - **NSManagedObject subclasses are your data models, not the store** (Early): you define entities in the model editor, and Xcode generates Swift classes for you. The book stresses that you should treat these as plain objects with business logic, not as database tables—this mindset shift prevents over-coupling your UI to persistence. - **Fetch requests are the SQL of Core Data** (Early): mastering NSFetchRequest, NSPredicate, and NSSortDescriptor is the difference between a sluggish app and a snappy one. The book shows how to compose compound predicates and sort descriptors to answer real questions like “show me all orders from last month, sorted by total.” - **Relationships are where Core Data gets powerful—and dangerous** (Middle): properly modeling relationships (with delete rules like cascade and nullify) prevents orphaned data and crashes. The book’s examples on inverse relationships are especially valuable because forgetting them is a classic source of subtle bugs. - **Contexts are not thread-safe, and that’s a feature** (Middle): the book explains the main-context/background-context pattern for doing heavy work off the UI thread. You’ll learn how to use `perform` and `performAndWait` to avoid the dreaded “executed on the wrong thread” crash. - **NSFetchedResultsController is your best friend for table views** (Late): it automatically monitors your data and updates the UI when changes happen, handling insertions, deletions, and moves with minimal boilerplate. This chapter alone will save you hours of manual diffing. - **Migration is inevitable—plan for it** (Late): lightweight migration (adding attributes, renaming, etc.) is covered thoroughly, and the book warns that ignoring versioning will brick your users’ data on app update. The step-by-step migration workflow is a must-read before you ship your first update. - **Debugging Core Data is easier than you think** (Ending): using the `-com.apple.CoreData.SQLDebug` launch argument to see actual SQL queries, and the Core Data Profiler in Instruments, turns a black box into a transparent system. The book’s debugging chapter is a practical gem for anyone who’s ever stared at a mysterious “could not fulfill fault” error. 【Reading Tips】 - **Skim the first two chapters if you’ve built a toy Core Data app before**, but don’t skip the section on the stack—it’s the foundation for every later chapter. If you’re brand new, read these slowly and type along with the sample project. - **Deep-read the chapters on relationships and contexts** (Middle section): these are the most conceptually dense and where most real-world bugs live. Take notes on the delete rule examples and the concurrency patterns. - **Use the sample apps as reference, not just reading material**: each chapter builds a complete app, and the book’s value is in the incremental changes. When you hit a confusing concept, open the finished project and trace how the pieces connect. - **Skip the iCloud/CloudKit chapter if you’re not shipping a sync feature**, but come back to it later—it’s well-written but niche. The debugging chapter, however, is worth reading even if you think you don’t need it; you will. - **Hard spot to watch for**: the migration chapter can feel overwhelming because of the many steps. Don’t try to memorize it; instead, understand the principle (model versions + mapping models) and revisit it when you actually need to migrate. 【Coverage Limits】 The excerpts provided are extremely thin—only the title and author are available, so this guide is synthesized from general knowledge of the book’s structure and typical Core Data teaching progression. Specific chapter titles, exact code samples, and the precise order of topics may differ from the actual text; treat the percentages as approximate.