Is Caching NSMangagedObject Instances A Bad Idea? - caching

Question

I have a core data entity called Product which is initially populated when the user first logs into the application. It can then be loaded again, if the user requests a refresh.
The Product entity is queried at several places in the app. So, I decided to implement a simple cache that can be shared across the app. The cache keeps the Product NSManagedObjects
in a map. Is this a bad idea?
The ProductCache class:
#interface ProductCache ()
#end
#implementation ProductCache {
}
static NSDictionary *productsDictionary = nil;
static ProductCache *sharedInstance;
+ (ProductCache *)sharedInstance {
#synchronized (self) {
if (sharedInstance == nil) {
sharedInstance = [[self alloc] init];
[sharedInstance reload];
}
}
return sharedInstance;
}
- (void) reload{
NSMutableDictionary *productsMap = [[NSMutableDictionary alloc] init];
CIAppDelegate *delegate = (CIAppDelegate *) [UIApplication sharedApplication].delegate;
NSManagedObjectContext *managedObjectContext = delegate.managedObjectContext;
NSArray *allProducts = [CoreDataManager getProducts:managedObjectContext];
for (Product *product in allProducts) {
[productsMap setObject:product forKey:product.productId];
}
productsDictionary = productsMap;
}
- (NSArray *)allProducts{
return [productsDictionary allValues];
}
- (Product *) productForId:(NSNumber *)productId {
return productId ? [productsDictionary objectForKey:productId] : nil;
}
#end

Answer 1

Personally I would not cache Core Data objects like this. Core Data is your cache. When you also factor in the the issue of threading (NSManagedObject instances cannot cross the thread boundary) it becomes even more risky to put an in memory cache on top of Core Data. This does not even take memory issues into consideration which all things being equal, your cache is not going to perform as well as Apple's cache (i.e. Core Data).
If you need instant access (vs. the nanosecond access on disk) to your Core Data objects then consider copying your on disk cache into an in memory cache and then access that. However, if nanosecond access times are sufficient, leave it in Core Data and fetch the entities when you need them. Build convenience methods for the fetch if you find it repetitive but don't put a cache on top.

Answer 2

I'd like to say it's unnecessary, but I guess it really depends on a few factors.
How large is the Products object?
Is the querying/re-querying extremely CPU intensive?
Does your main thread get blocked?
Personally, I think you could avoid caching and simply re-query the Products object on a background thread whenever you need it.
The better question to ask is: Is it even worthwhile using Core Data for this specific aspect of your project?
Why not store the dictionary in NSUserDefaults (if your has is small)?