能否为UICollectionViewDiffableDataSource的类型使用协议？

方案一：类型擦除包装协议实例 #

Swift中any PresentableItem这种存在类型无法直接满足Hashable的静态约束，你可以通过类型擦除包装符合协议的实例，生成一个具体的Hashable类型：

1. 调整协议定义，拆分Hashable的约束为协议方法：

protocol PresentableItem {
    var title: String? { get }
    // 声明哈希与相等判断的核心方法
    func hash(into hasher: inout Hasher)
    func isEqual(to other: PresentableItem) -> Bool
}

// 给本身已实现Hashable的类型提供默认实现
extension PresentableItem where Self: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(self)
    }
    
    func isEqual(to other: PresentableItem) -> Bool {
        guard let other = other as? Self else { return false }
        return self == other
    }
}

2. 创建类型擦除的包装结构体，实现Hashable：

struct AnyPresentableItem: Hashable {
    private let base: PresentableItem
    private let hashHandler: (inout Hasher) -> Void
    private let equalsHandler: (AnyPresentableItem) -> Bool
    
    init<T: PresentableItem>(_ base: T) where T: Hashable {
        self.base = base
        self.hashHandler = base.hash(into:)
        self.equalsHandler = { other in
            guard let otherBase = other.base as? T else { return false }
            return base.isEqual(to: otherBase)
        }
    }
    
    // 暴露协议定义的展示属性
    var title: String? { base.title }
    
    // 实现Hashable的必要方法
    func hash(into hasher: inout Hasher) {
        hashHandler(&hasher)
    }
    
    static func == (lhs: AnyPresentableItem, rhs: AnyPresentableItem) -> Bool {
        lhs.equalsHandler(rhs)
    }
}

3. 用包装体作为数据源的泛型参数：

dataSource = UICollectionViewDiffableDataSource<Int, AnyPresentableItem>(collectionView: collectionView) { collectionView, indexPath, item in
    let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "Cell", for: indexPath) as! CustomCell
    cell.titleLabel.text = item.title
    return cell
}

4. 让CoreData类和其他数据类实现协议：

// CoreData类（NSManagedObject本身已实现Hashable）
extension SomeDataItemClass: PresentableItem {}

// 非CoreData的测试类
struct MockDisplayItem: PresentableItem, Hashable {
    var title: String?
}

方案二：使用展示专用DTO结构体（推荐） #

如果不想处理类型擦除的复杂逻辑，你提到的“用结构体作为数据源类型”是更简洁直接的解耦方案：

1. 定义仅用于展示的结构体，实现Hashable：

struct DisplayItem: Hashable {
    let title: String?
    // 用唯一标识符保证哈希与相等判断的准确性
    let uniqueId: String
    
    static func == (lhs: DisplayItem, rhs: DisplayItem) -> Bool {
        lhs.uniqueId == rhs.uniqueId
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(uniqueId)
    }
}

2. 给CoreData类添加转换方法：

extension SomeDataItemClass {
    func toDisplayItem() -> DisplayItem {
        // 用CoreData对象的objectID作为唯一标识
        return DisplayItem(title: self.title, uniqueId: self.objectID.uuidString)
    }
}

3. 直接用DisplayItem作为数据源泛型：

dataSource = UICollectionViewDiffableDataSource<Int, DisplayItem>(collectionView: collectionView) { collectionView, indexPath, item in
    let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "Cell", for: indexPath) as! CustomCell
    cell.titleLabel.text = item.title
    return cell
}

4. 更新数据源时统一转换为DisplayItem：

var snapshot = NSDiffableDataSourceSnapshot<Int, DisplayItem>()
snapshot.appendSections([0])
let displayItems = coreDataItems.map { $0.toDisplayItem() }
snapshot.appendItems(displayItems)
dataSource.apply(snapshot)

方案对比 #

• 类型擦除方案：保留了原数据对象的类型灵活性，无需额外转换，但代码量较大，适合需要保留原对象上下文的场景。
• DTO结构体方案：代码简洁、逻辑清晰，完全隔离展示层与数据层，是iOS开发中解耦的常用方案，推荐优先使用。

内容的提问来源于stack exchange，提问作者user366126