I'm using the new NSDiffableDataSourceSnapshot and UITableViewDiffableDataSource with a UITableView. I'm having no problems building the table but I'm having problems updating a cell when the data shown in it changes. I haven't found any Apple documentation explaining how to do this. I've tried the following:
self.currentSnapshot.reloadItems([Item(identifier: identifier)])
self.dataSource.apply(self.currentSnapshot)
I get the following error in reloadItems:
Assertion failure in -[__UIDiffableDataSourceSnapshot _reloadViewUpdatesForDiffUpdate:dataSource:ignoreInvalidItems:]
I have checked that the identifier passed to the Item initializer already exists in the snapshot.
Here is my Item class:
class Item: Hashable, Equatable {
let identifier: String
var matchWrapper: MatchWrapper
init(matchWrapper: MatchWrapper) {
self.identifier = matchWrapper.identifier
self.matchWrapper = matchWrapper
}
func hash(into hasher: inout Hasher) {
hasher.combine(self.identifier)
}
static func == (lhs: ScoresViewController.Item, rhs: ScoresViewController.Item) -> Bool {
return lhs.identifier == rhs.identifier
}
}
Any suggestions?
I have had similar problems and after a lot of debugging and trying out different things I've come to the conclusion that I don't think you should be using reloadItems
. reloadItems
doesn't actually seem to do anything from my testing. The cell provider always provides the old data and if you have a hash function based on an identifier and an equatable function that checks for equality on things other than the identifier, you get an error.
There are two things that you can try
if you really want to use reload items in the cellProvider instead of using the data provided by the closure, use your own data source as the source of truth to lay out the cells. (this sort of defeats the purpose of diffableDataSource in my opinion though). You end up missing out on some of the great functionality of DiffableDataSource
instead of writing code like this:
var snapshot = tableView.snapshot()
let item = items[indexPath.row]
snapshot.reloadItems([item])
you can do this
let snapshot: NSDiffableDataSourceSnapshot<Section,Item> = .init()
// assuming wherever you're storing your data is already updated
snapshot.appendItems([items])
dataSource.apply(snapshot)
This should refresh only the items in the snapshot that have changes. From my understanding, the current snapshot of the tableView is compared with the newly created snapshot and only items that are different should be updated. I could be wrong here, but this is what has worked for me.
Other suggestions I've seen:
func hash(into hasher: inout Hasher) {
hasher.combine(id)
hasher.combine(name)
hasher.combine(title)
}
however if you go this route this means that reloadItems will throw an error reporting that this doesn't exist in the data source so you'll have to add this and delete the old data manually
This worked or me:
func handleNewItems(_ newItems: [SomeItem]) {
var snapShot = dataSource.snapshot()
let diff = newItems.difference(from: snapShot.itemIdentifiers)
let currentIdentifiers = snapShot.itemIdentifiers
guard let newIdentifiers = currentIdentifiers.applying(diff) else {
return
}
snapShot.deleteItems(currentIdentifiers)
snapShot.appendItems(newIdentifiers)
dataSource.apply(snapShot, animatingDifferences: true)
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With