Difference between dequeueReusableCellWithReuseIdentifier: and cellForItemAtIndexPath:

Question

I have been wondering why my code works well with cellForItemAtIndexPath: & not with dequeueReusableCellWithReuseIdentifier: while fetching collection view cells.

Here is my code:

This one works Fine:

NSInteger numberOfCells = [self.collectionView numberOfItemsInSection:0];
    for (NSInteger i = 0; i < numberOfCells; i++) {
        myCustomCollectionCell *cell = (myCustomCollectionCell *)[self.collectionView cellForItemAtIndexPath:[NSIndexPath indexPathForItem:i inSection:0]];
        //here I use the cell..
    }

While this compiles well, but not working (the changes I perform on cell is not depicted)

NSInteger numberOfCells = [self.collectionView numberOfItemsInSection:0];
        for (NSInteger i = 0; i < numberOfCells; i++) {
            myCustomCollectionCell *cell = [self.collectionView dequeueReusableCellWithReuseIdentifier:@"myCell"forIndexPath:[NSIndexPath indexPathForItem:i inSection:0]];
            //here I use the cell..
        }

Tried this too, but no use:

NSInteger numberOfCells = [self.collectionView numberOfItemsInSection:0];
        for (NSInteger i = 0; i < numberOfCells; i++) {
            myCustomCollectionCell *cell = (myCustomCollectionCell *)[self.collectionView dequeueReusableCellWithReuseIdentifier:@"myCell"forIndexPath:[NSIndexPath indexPathForItem:i inSection:0]];
            //here I use the cell..
        }

Any ideas?

Answer 1

These two are basically two very different methods.

1. dequeReusableCellWithReuseIdentifier: Suppose that you have a list of articles to view. Say you have 50 articles. The screen won't show you all 50 articles on screen at once. It will show you limited cells at once, based on the height you given to the rows. Lets say the screen shows only 5 articles at once and now you are at the top of the list. The list will show items 1-5. Now when you scroll, inorder to display the 6th item, the list reuses your 1st cell, configures it for the 6th one and display it. By this time your 1st cell is out of the view.

2.cellForRowAtIndexPath : On the other hand cellForRowAtIndexPath returns you the cell which is already in the view or from IndexPath you provide. In this case if the cell is already in the memory, it will just return that or it will configure a new cell and return.

The example below is for UITableViews, but UICollectionViews can be handled in the same way.

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {

    /*
     *   This is an important bit, it asks the table view if it has any available cells
     *   already created which it is not using (if they are offscreen), so that it can
     *   reuse them (saving the time of alloc/init/load from xib a new cell ).
     *   The identifier is there to differentiate between different types of cells
     *   (you can display different types of cells in the same table view)
     */

    UITableViewCell *cell = [tableView dequeueReusableCellWithReuseIdentifier:@"MyIdentifier"];

    /*
     *   If the cell is nil it means no cell was available for reuse and that we should
     *   create a new one.
     */
    if (cell == nil) {

        /* 
         *   Actually create a new cell (with an identifier so that it can be dequeued).   
         */

        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:@"MyIdentifier"] autorelease];

    }

    /*
     *   Now that we have a cell we can configure it to display the data corresponding to
     *   this row/section
     */

    //Configure the cell here..


    /* Now that the cell is configured we return it to the table view so that it can display it */


    return cell;

}

Let me know if you were still unclear.

Answer 2

They are different things:

• cellForItemAtIndexPath gets an already-populated cell from the collection view.
• dequeueReusableCellWithReuseIdentifier will possibly return a cell that can be re-used, when populating a new cell. It's designed to help reduce the number of cell objects in existence. If it fails (and it often will) then a new cell must be created explicitly.