reloadData when loop is done - ios

Question

I have a loadItem functions which is suppose to load items from a parse server. This include a loop where i'm at the end is saving the data to an array:
itemArray?.addObject(arrayDic)
When this is saved i would like to reloadData of the collectionView. therefor i've inserted it into a dispatch_async block, but it still seems like it is being run before the data is saved into the itemArray array since the itemArray.count is 0 and i've checked inside the loop that the data is saved into the array. What am i doing wrong?
func loadItems() {
var query = PFQuery(className:"Items")
query.orderByAscending("createdAt")
query.findObjectsInBackgroundWithBlock {
(objects: [AnyObject]!, error: NSError!) -> Void in
if error == nil {
for object in objects {
var imageRelation: PFRelation = object.relationForKey("pictures")
var query = imageRelation.query()
query.orderByDescending("createdAt")
query.findObjectsInBackgroundWithBlock {
(imageObjects: [AnyObject]!, error: NSError!) -> Void in
if error == nil {
var theArray = imageObjects as NSArray
var arrayDic = NSMutableDictionary()
let imageFile = theArray.objectAtIndex(0).objectForKey("image") as PFFile
imageFile.getDataInBackgroundWithBlock {
(imageData: NSData!, error: NSError!) -> Void in
if !(error != nil) {
let image = UIImage(data:imageData)
arrayDic.setValue(object.objectForKey("price"), forKey: "price")
arrayDic.setValue(image, forKey: "image")
itemArray?.addObject(arrayDic)
}
}
}
}
}
dispatch_async(dispatch_get_main_queue()) {
println(itemArray?.count)
self.collectionView.reloadData()
}
} else {
// Log details of the failure
NSLog("Error: %# %#", error, error.userInfo!)
}
}
}

Answer 1

I would not advise trying to make the requests synchronous (as that can significantly slow down the process, unless you scheduled them to run concurrently on some concurrent background queue). I would suggest, instead, a pattern that allows you to keep the asynchronous requests, but notifies you of their completion. One such pattern is the dispatch group, in which you:
create a dispatch group:
let group = dispatch_group_create()
for every iteration of your loop, call dispatch_group_enter:
dispatch_group_enter(group)
win the completion block of the asynchronous method, call dispatch_group_leave:
dispatch_group_leave(group)
specify what you want to do when the dispatch group is complete:
dispatch_group_notify(group, dispatch_get_main_queue()) {
println(self.itemArray?.count)
self.collectionView.reloadData()
}
When all of the calls to dispatch_group_enter are offset by the final dispatch_group_leave call, the notification block will be called for you.
So, looking at the code as you loop through the objects, it might look something like:
let group = dispatch_group_create()
for object in objects {
dispatch_group_enter(group)
// do some stuff
query.findObjectsInBackgroundWithBlock {
(imageObjects: [PFObject]!, error: NSError!) -> Void in
if error == nil {
// do some more stuff
imageFile.getDataInBackgroundWithBlock {
(imageData: NSData!, error: NSError!) -> Void in
if !(error != nil) {
// do even some more stuff
}
dispatch_group_leave(group)
}
} else {
dispatch_group_leave(group)
}
}
}
dispatch_group_notify(group, dispatch_get_main_queue()) {
println(self.itemArray?.count)
self.collectionView.reloadData()
}
Their are other functionally equivalent patterns (e.g. custom concurrent dispatch queue with the final reloadData dispatched with a barrier; make these individual requests NSOperation objects that you add to NSOperationQueue and create separate completion operation that is dependent upon those other operations; etc.), but the dispatch group seems to entail the least refactoring of this code. Regardless, hopefully this illustrates the basic idea: Make the final reload only be triggered when the other asynchronous requests are done.