如何按需将Realm Results<PersistedItem>转换为非第三方依赖的[Item]？

1. 自定义懒加载集合包装器（推荐） #

自己实现一个遵循RandomAccessCollection的泛型结构体，仅在访问下标时执行映射转换，既隔离Realm依赖，又保证SwiftUI List能正常懒加载。

实现代码 #

import Foundation

// 泛型懒加载映射集合，兼容RandomAccessCollection协议
struct LazyMappedCollection<Source: RandomAccessCollection, Target>: RandomAccessCollection {
    typealias Index = Source.Index
    typealias Element = Target
    
    private let source: Source
    private let transform: (Source.Element) -> Target
    
    init(source: Source, transform: @escaping (Source.Element) -> Target) {
        self.source = source
        self.transform = transform
    }
    
    var startIndex: Index { source.startIndex }
    var endIndex: Index { source.endIndex }
    
    subscript(position: Index) -> Target {
        // 仅当下标被访问时才执行转换逻辑
        transform(source[position])
    }
    
    func index(after i: Index) -> Index {
        source.index(after: i)
    }
    
    func index(before i: Index) -> Index {
        source.index(before: i)
    }
    
    func index(_ i: Index, offsetBy distance: Int) -> Index {
        source.index(i, offsetBy: distance)
    }
}

// 给RandomAccessCollection加扩展，简化懒加载映射集合的创建
extension RandomAccessCollection {
    func lazyMap<T>(_ transform: @escaping (Element) -> T) -> LazyMappedCollection<Self, T> {
        LazyMappedCollection(source: self, transform: transform)
    }
}

仓库层适配 #

修改仓库协议，返回遵循RandomAccessCollection的类型（避免直接返回[Item]，因为数组会触发全量立即加载）：

// 抽象仓库协议，完全隔离Realm依赖
protocol ItemRepository {
    func fetchItems() -> some RandomAccessCollection where Element == Item
}

// Realm实现的具体仓库
class RealmItemRepository: ItemRepository {
    func fetchItems() -> some RandomAccessCollection where Element == Item {
        guard let realm = try? Realm() else {
            return []
        }
        let persistedItems = realm.objects(PersistedItem.self)
        // 返回懒加载映射集合，仅在访问元素时执行转换
        return persistedItems.lazyMap { persistedItem in
            Item(id: persistedItem.id, name: persistedItem.name, ...)
        }
    }
}

SwiftUI视图使用 #

直接将集合传入List即可，SwiftUI会自动按需加载元素：

struct ItemListView: View {
    @StateObject private var repository: ItemRepository = RealmItemRepository()
    
    var body: some View {
        List(repository.fetchItems()) { item in
            Text(item.name)
        }
    }
}

// 自定义Item需遵循Identifiable，或给List指定id参数
struct Item: Identifiable {
    let id: UUID
    let name: String
    // 其他业务属性
}

2. 结合Swift原生LazySequence（进阶） #

如果不想自定义集合，可借助Swift原生LazySequence，但需要包装成RandomAccessCollection才能适配SwiftUI List的高效懒加载：

extension Results {
    func lazyMapToItem() -> some RandomAccessCollection<Item> {
        self.lazy.map { persistedItem in
            Item(id: persistedItem.id, name: persistedItem.name)
        }
        // 复用之前的自定义包装器，保证RandomAccessCollection兼容性
        return LazyMappedCollection(source: self, transform: { $0.toItem() })
    }
}

// 给PersistedItem加转换扩展，简化代码
extension PersistedItem {
    func toItem() -> Item {
        Item(id: self.id, name: self.name, ...)
    }
}

关键注意事项 #

• 线程安全：Realm的Results仅能在创建它的线程访问，仓库方法需保证在正确线程调用（比如用专属Realm队列，或在主线程操作已配置为主线程的Realm实例）。
• 自动更新：由于包装器持有RealmResults的引用，当Realm数据变化时，LazyMappedCollection会自动同步最新数据，SwiftUI会触发视图刷新，无需额外处理。
• 禁止提前遍历：不要在仓库或视图层提前调用Array()、forEach()等方法，否则会触发全量转换，破坏懒加载效果。

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