Question

Part of my iOS project polls a server for sets of objects, then converts and saves them to Core Data, to then update the UI with the results. The server tasks happens in a collection of NSOperation classes I call ‘services’ that operate in the background. If NSManagedObject and its ~Context were thread safe, I would have had the services call delegate methods on the main thread like this one:

- (void)service:(NSOperation *)service retrievedObjects:(NSArray *)objects;

Of course you can’t pass around NSManagedObjects like this, so this delegate method is doomed. As far as I can see there are two solutions to get to the objects from the main thread. But I like neither of them, so I was hoping the great StackOverflow community could help me come up with a third.

1. I could perform an NSFetchRequest on the main thread to pull in the newly added or modified objects. The problem is that the Core Data store contains many more of these objects, so I have to add quite some verbosity to communicate the right set of objects. One way would be to add a property to the object like batchID, which I could then pass back to the delegate so it would know what to fetch. But adding data to the store to fix my concurrency limitations feels wrong.

2. I could also collect the newly added objects’ objectID properties, put them in a list and send that list to the delegate method. The unfortunate thing though is that I have to populate the list after I save the context, which means I have to loop over the objects twice in the background before I have the correct list (first time is when parsing the server response). Then I still only have a list of objectIDs, which I have to individually reel in with existingObjectWithID:error: from the NSManagedObjectContext on the main thread. This just seems so cumbersome.

What piece of information am I missing? What’s the third solution to bring a set of NSManagedObjects from a background thread to the main thread, without losing thread confinement?

Answer 1

epologee,

While you obviously have a solution you are happy with, let me suggest that you lose some valuable information, whether items are updated, deleted or inserted, with your mechanism. In my code, I just migrate the userInfo dictionary to the new MOC. Here is a general purpose routine to do so:

// Migrate a userInfo dictionary as defined by NSManagedObjectContextDidSaveNotification
// to the receiver context.
- (NSDictionary *) migrateUserInfo: (NSDictionary *) userInfo {

    NSMutableDictionary *ui = [NSMutableDictionary dictionaryWithCapacity: userInfo.count];

    NSSet        *  sourceSet = nil;
    NSMutableSet *migratedSet = nil;

    for (NSString *key in [userInfo allKeys]) {

        sourceSet   = [userInfo valueForKey: key];
        migratedSet = [NSMutableSet setWithCapacity: sourceSet.count];

        for (NSManagedObject *mo in sourceSet) {

            [migratedSet addObject: [self.moc objectWithID: mo.objectID]];
        }
        [ui setValue: migratedSet forKey: key];
    }
    return ui;

} // -migrateUserInfo:

The above routine assumes it is a method of a class which has an @property NSManagedObjectContext *moc.

I hope you find the above useful.

Andrew