Does Core Store isolate the developer's context?

No, Core Data does not isolate the developer's context in terms of complete data or object isolation between different threads or instances of NSManagedObjectContext.

Each NSManagedObjectContext acts as a "notebook" for working with data from the persistent store. Objects (NSManagedObject) can be registered in one or multiple contexts.

Context isolation is implemented as follows:

• Data consistency: Each context monitors changes in its registered objects. Changes in one context are not immediately visible in another until they are saved (save()) and other contexts "receive" these changes (for example, through NSManagedObjectContextDidSaveNotification notifications or the automaticallyMergesChangesFromParent mechanism).
• Thread Concurrency: NSManagedObjectContext is not thread-safe. Access to the context and its objects should only be from the thread or queue on which the context was created. Core Data provides mechanisms for working with contexts across different threads:
  • mainQueueConcurrencyType: Context tied to the main queue. Used for UI.
  • privateQueueConcurrencyType: Context operating on its own private queue. Used for background operations.

Interaction between contexts usually occurs through saving and merging changes.

// Example of creating contexts with different queue types
let mainContext = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
mainContext.persistentStoreCoordinator = persistentStoreCoordinator

let privateContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
privateContext.persistentStoreCoordinator = persistentStoreCoordinator // You can use the same coordinator
// privateContext.parent = mainContext // Or set up a parent-child relationship

Using the same NSManagedObject object across different threads without proper Context-Thread affinity will lead to crashes. To safely pass objects between contexts, NSManagedObjectID is used.

// Getting the object ID from one context
let objectID = myObject.objectID

// Accessing the object in another context
let otherContextObject = otherContext.object(with: objectID)

Thus, Core Data provides concurrent access with context-level isolation, not at the data or object level, requiring work with the context in its "native" thread/queue. The developer is responsible for proper thread management and synchronization between contexts.