在 CoreData 更新期间为 UICollectionView 替换 NSFetchedResultsController 时崩溃

Question

我有一个 UICollectionView，它从 NSFetchedResultsController 接收它的内容。 数据来自多个 API-Endpoints（服务器的设计不在我手中）。 第一次调用提供元数据，然后对于每个条目 (> 10.000)，必须有一个 API-Call 来获取相关数据。

CollectionView 可以针对多个属性进行过滤，每个过滤器需要不同的 sectionNameKeyPath

因此，当用户更改过滤器时，我将不得不用新的 FRC 替换当前的 FRC。但是当 CoreData 更新时，应用程序会崩溃

*** Assertion failure in -[UICollectionView _endItemAnimationsWithInvalidationContext:tentativelyForReordering:], /BuildRoot/Library/Caches/com.apple.xbs/Sources/UIKit_Sim/UIKit-3512.60.7/UICollectionView.m:4422
*** Terminating app due to uncaught exception 'NSInternalInconsistencyException', reason: 'attempt to delete item 9 from section 0 which only contains 1 items before the update'

那么有什么办法可以避免这种崩溃吗？

编辑：为 NSFetchedResultsControllerDelegate 添加代码：

#pragma mark - NSFetchedResultsControllerDelegate

- (void)controllerWillChangeContent:(NSFetchedResultsController *)controller
{
   _objectChanges = [NSMutableDictionary dictionary];
   _sectionChanges = [NSMutableDictionary dictionary];
}

- (void)controller:(NSFetchedResultsController *)controller
 didChangeSection:(id <NSFetchedResultsSectionInfo>)sectionInfo
          atIndex:(NSUInteger)sectionIndex
    forChangeType:(NSFetchedResultsChangeType)type
{


   if (type == NSFetchedResultsChangeInsert || type == NSFetchedResultsChangeDelete) {
       NSMutableIndexSet *changeSet = _sectionChanges[@(type)];
       if (changeSet != nil) {
           [changeSet addIndex:sectionIndex];
       } else {
           _sectionChanges[@(type)] = [[NSMutableIndexSet alloc] initWithIndex:sectionIndex];
       }
   }

}

- (void)controller:(NSFetchedResultsController *)controller didChangeObject:(id)anObject
      atIndexPath:(NSIndexPath *)indexPath forChangeType:(NSFetchedResultsChangeType)type
     newIndexPath:(NSIndexPath *)newIndexPath
{

   NSMutableArray *changeSet = _objectChanges[@(type)];
   if (changeSet == nil) {
       changeSet = [[NSMutableArray alloc] init];
       _objectChanges[@(type)] = changeSet;
   }

   switch(type) {
       case NSFetchedResultsChangeInsert:
           [changeSet addObject:newIndexPath];
           break;
       case NSFetchedResultsChangeDelete:
           [changeSet addObject:indexPath];
           break;
       case NSFetchedResultsChangeUpdate:
           [changeSet addObject:indexPath];
           break;
       case NSFetchedResultsChangeMove:
           [changeSet addObject:@[indexPath, newIndexPath]];
           break;
   }

}

- (void)controllerDidChangeContent:(NSFetchedResultsController *)controller
{

   NSMutableArray *moves = _objectChanges[@(NSFetchedResultsChangeMove)];
   if ([moves count] > 0) {
       NSMutableArray *updatedMoves = [[NSMutableArray alloc] initWithCapacity:[moves count]];

       NSMutableIndexSet *insertSections = _sectionChanges[@(NSFetchedResultsChangeInsert)];
       NSMutableIndexSet *deleteSections = _sectionChanges[@(NSFetchedResultsChangeDelete)];
       for (NSArray *move in moves) {
           NSIndexPath *oldIndexPath = move[0];
           NSIndexPath *newIndexPath = move[1];

           if ([deleteSections containsIndex:[oldIndexPath section]]) {
               if (![insertSections containsIndex:[newIndexPath section]]) {
                   NSMutableArray *changeSet = _objectChanges[@(NSFetchedResultsChangeInsert)];
                   if (changeSet == nil) {
                       changeSet = [[NSMutableArray alloc] initWithObjects:newIndexPath, nil];
                       _objectChanges[@(NSFetchedResultsChangeInsert)] = changeSet;
                   } else {
                       [changeSet addObject:newIndexPath];
                   }
               }
           } else if ([insertSections containsIndex:[newIndexPath section]]) {
               NSMutableArray *changeSet = _objectChanges[@(NSFetchedResultsChangeDelete)];
               if (changeSet == nil) {
                   changeSet = [[NSMutableArray alloc] initWithObjects:oldIndexPath, nil];
                   _objectChanges[@(NSFetchedResultsChangeDelete)] = changeSet;
               } else {
                   [changeSet addObject:oldIndexPath];
               }
           } else {
               [updatedMoves addObject:move];
           }
       }

       if ([updatedMoves count] > 0) {
           _objectChanges[@(NSFetchedResultsChangeMove)] = updatedMoves;
       } else {
           [_objectChanges removeObjectForKey:@(NSFetchedResultsChangeMove)];
       }
   }

   NSMutableArray *deletes = _objectChanges[@(NSFetchedResultsChangeDelete)];
   if ([deletes count] > 0) {
       NSMutableIndexSet *deletedSections = _sectionChanges[@(NSFetchedResultsChangeDelete)];
       [deletes filterUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(NSIndexPath *evaluatedObject, NSDictionary *bindings) {
           return ![deletedSections containsIndex:evaluatedObject.section];
       }]];
   }

   NSMutableArray *inserts = _objectChanges[@(NSFetchedResultsChangeInsert)];
   if ([inserts count] > 0) {
       NSMutableIndexSet *insertedSections = _sectionChanges[@(NSFetchedResultsChangeInsert)];
       [inserts filterUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(NSIndexPath *evaluatedObject, NSDictionary *bindings) {
           return ![insertedSections containsIndex:evaluatedObject.section];
       }]];
   }

   UICollectionView *collectionView = self.collectionView;
   [collectionView performBatchUpdates:^{

       NSIndexSet *deletedSections = _sectionChanges[@(NSFetchedResultsChangeDelete)];
       if ([deletedSections count] > 0) {
           [collectionView deleteSections:deletedSections];
       }

       NSIndexSet *insertedSections = _sectionChanges[@(NSFetchedResultsChangeInsert)];
       if ([insertedSections count] > 0) {
           [collectionView insertSections:insertedSections];
       }

       NSArray *deletedItems = _objectChanges[@(NSFetchedResultsChangeDelete)];
       if ([deletedItems count] > 0) {
           [collectionView deleteItemsAtIndexPaths:deletedItems];
       }

       NSArray *insertedItems = _objectChanges[@(NSFetchedResultsChangeInsert)];
       if ([insertedItems count] > 0) {
           [collectionView insertItemsAtIndexPaths:insertedItems];
       }

       NSArray *reloadItems = _objectChanges[@(NSFetchedResultsChangeUpdate)];
       if ([reloadItems count] > 0) {
           [collectionView reloadItemsAtIndexPaths:reloadItems];
       }

       NSArray *moveItems = _objectChanges[@(NSFetchedResultsChangeMove)];
       for (NSArray *paths in moveItems) {
           [collectionView moveItemAtIndexPath:paths[0] toIndexPath:paths[1]];
       }
   } completion:^(BOOL finished) {
       [[self refreshControl] endRefreshing];

   }];

   _objectChanges = nil;
   _sectionChanges = nil;

}

Answer 1

虽然您的批处理代码看起来既聪明又高效，但很难确保这批更改是有说服力的。如果插入或删除任何部分，或者移动任何项目，那么很难确保所有其他索引路径都正确并引用适当的项目。

如果有任何部分插入或删除，我会重新加载。如果同时有移动的项目和其他任何东西，我会重新加载。如果您在同一部分同时有多个插入和删除，它可以工作，它可能会用错误的数据刷新屏幕。

您需要非常小心地对集合中的部分和部分内容进行复合更改。

您没有为您的 FRC 更改显示任何代码，我想这无关紧要。切换时一定要重新加载。