我使用DiffUtil.Callbackand做了一个快速示例ListAdapter<T, K>（所以我在适配器上调用了 submitList(...) ），没有任何问题。
然后我将适配器修改为普通适配器，RecyclerView.Adapter并在其中构造了一个 AsyncDiffUtil（使用上面相同的 DiffUtil.Callback）。
架构是：
- 活动 -> 片段（包含 RecyclerView）。
- 适配器
- 视图模型
- “假存储库”仅包含一个
val source: MutableList<Thing> = mutableListOf()
模型
我创建了一个Thing对象：data class Thing(val name: String = "", val age: Int = 0).
为了便于阅读，我添加了typealias Things = List<Thing>（少打字）。;)
存储库
从某种意义上说，它是假的，项目的创建方式如下：
private fun makeThings(total: Int = 20): List<Thing> {
val things: MutableList<Thing> = mutableListOf()
for (i in 1..total) {
things.add(Thing("Name: $i", age = i + 18))
}
return things
}
但是“源”是（类型别名）的可变列表。
回购可以做的另一件事是“模拟”对随机项目的修改。我只是创建了一个新的数据类实例，因为它显然都是不可变的数据类型（它们应该是）。请记住，这只是模拟可能来自 API 或 DB 的真实更改。
fun modifyItemAt(pos: Int = 0) {
if (source.isEmpty() || source.size <= pos) return
val thing = source[pos]
val newAge = thing.age + 1
val newThing = Thing("Name: $newAge", newAge)
source.removeAt(pos)
source.add(pos, newThing)
}
视图模型
这里没什么特别的，它谈论并持有对 的引用ThingsRepository，并公开一个 LiveData：
private val _state = MutableLiveData<ThingsState>(ThingsState.Empty)
val state: LiveData<ThingsState> = _state
“状态”是：
sealed class ThingsState {
object Empty : ThingsState()
object Loading : ThingsState()
data class Loaded(val things: Things) : ThingsState()
}
viewModel 有两个公共方法（除了val state）：
fun fetchData() {
viewModelScope.launch(Dispatchers.IO) {
_state.postValue(ThingsState.Loaded(repository.fetchAllTheThings()))
}
}
fun modifyData(atPosition: Int) {
repository.modifyItemAt(atPosition)
fetchData()
}
没什么特别的，只是一种按位置修改随机项目的方法（记住这只是一个快速的测试方法）。
因此 FetchData 启动 IO 中的异步代码以“获取”（实际上，如果列表存在，则返回缓存列表，仅在 repo 中“生成”数据的第一次）。
修改数据更简单，在 repo 上调用 modify 并获取数据以发布新值。
适配器
很多样板......但正如所讨论的，它只是一个适配器：
class ThingAdapter(private val itemClickCallback: ThingClickCallback) :
RecyclerView.Adapter<RecyclerView.ViewHolder>() {
ThingClickCallback只是：
interface ThingClickCallback {
fun onThingClicked(atPosition: Int)
}
这个适配器现在有一个 AsyncDiffer...
private val differ = AsyncListDiffer(this, DiffUtilCallback())
this在这种情况下是实际的适配器（不同的需要），DiffUtilCallback只是一个DiffUtil.Callback实现：
internal class DiffUtilCallback : DiffUtil.ItemCallback<Thing>() {
override fun areItemsTheSame(oldItem: Thing, newItem: Thing): Boolean {
return oldItem.name == newItem.name
}
override fun areContentsTheSame(oldItem: Thing, newItem: Thing): Boolean {
return oldItem.age == newItem.age && oldItem.name == oldItem.name
}
这里没什么特别的。
适配器中唯一的特殊方法（除了 onCreateViewHolder 和 onBindViewHolder）是：
fun submitList(list: Things) {
differ.submitList(list)
}
override fun getItemCount(): Int = differ.currentList.size
private fun getItem(position: Int) = differ.currentList[position]
所以我们要求differ为我们做这些并公开公共方法submitList来模拟 a listAdapter#submitList(...)，除非我们委托给不同的。
因为您可能想知道，这里是 ViewHolder：
internal class ViewHolder(itemView: View, private val callback: ThingClickCallback) :
RecyclerView.ViewHolder(itemView) {
private val title: TextView = itemView.findViewById(R.id.thingName)
private val age: TextView = itemView.findViewById(R.id.thingAge)
fun bind(data: Thing) {
title.text = data.name
age.text = data.age.toString()
itemView.setOnClickListener { callback.onThingClicked(adapterPosition) }
}
}
不要太苛刻，我知道我直接通过了点击监听器，我只有大约 1 小时来完成这一切，但没什么特别的，布局只是两个文本视图（年龄和姓名），我们将整行设置为可点击将位置传递给回调。这里也没什么特别的。
最后但同样重要的是，Fragment.
分段
class ThingListFragment : Fragment() {
private lateinit var viewModel: ThingsViewModel
private var binding: ThingsListFragmentBinding? = null
private val adapter = ThingAdapter(object : ThingClickCallback {
override fun onThingClicked(atPosition: Int) {
viewModel.modifyData(atPosition)
}
})
...
它有 3 个成员变量。ViewModel、Binding（我使用 ViewBinding 为什么不只是 gradle 中的 1 个衬里）和 Adapter（为了方便起见，它在 ctor 中采用 Click 侦听器）。
在这个例子中，我只是用“修改位置 (X) 的项目”来调用视图模型，其中 X = 在适配器中单击的项目的位置。（我知道这可以更好地抽象，但这在这里无关紧要）。
这个片段中只有两个其他实现的方法......
销毁：
override fun onDestroy() {
super.onDestroy()
binding = null
}
（我想知道 Google 是否会接受他们在 Fragment 生命周期方面的错误，我们仍然必须关注这一点）。
不管怎样，其他的也就不足为奇了，onCreateView。
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
val root = inflater.inflate(R.layout.things_list_fragment, container, false)
binding = ThingsListFragmentBinding.bind(root)
viewModel = ViewModelProvider(this).get(ThingsViewModel::class.java)
viewModel.state.observe(viewLifecycleOwner) { state ->
when (state) {
is ThingsState.Empty -> adapter.submitList(emptyList())
is ThingsState.Loaded -> adapter.submitList(state.things)
is ThingsState.Loading -> doNothing // Show Loading? :)
}
}
binding?.thingsRecyclerView?.adapter = adapter
viewModel.fetchData()
return root
}
绑定东西（root/binding），获取viewModel，观察“状态”，在recyclerView中设置adapter，调用viewModel开始取数据。
就这样。
那么它是如何工作的呢？
应用程序启动，创建片段，订阅 VM stateLiveData，并触发数据获取。ViewModel 调用 repo，它是空的（新的），所以 makeItems 被称为列表现在有项目并缓存在 repo 的“源”列表中。viewModel 异步接收这个列表（在协程中）并发布 LiveData 状态。片段接收状态并发布（提交）到适配器以最终显示一些东西。
当您“单击”一个项目时，ViewHolder（具有单击侦听器）触发对接收位置的片段的“回调”，然后将其传递到 Viewmodel 并且这里的数据在 Repo 中发生突变，这再次, 推送相同的列表，但在已修改的单击项目上具有不同的引用。这会导致 ViewModel 将具有与以前相同的列表引用的新 LIveData 状态推送到片段，该片段再次接收该状态，并执行 adapter.submitList(...)。
适配器异步计算这个并且 UI 更新。
它有效，如果您想玩得开心，我可以将所有这些都放在 GitHub 中，但我的观点是，虽然对 AsyncDiffer 的担忧是有效的（并且可能是或曾经是真的），但这似乎不是我的（超级有限） 经验。
您是否以不同的方式使用它？
当我点击任何行时，更改将从存储库传播
更新：忘记包含doNothing功能：
val doNothing: Unit
get() = Unit
我已经使用了一段时间，我通常使用它，因为它比XXX -> {}我读得更好。:)