如何在CoreData中实现FetchRequest与SectionedFetchRequest的动态切换？

核心思路是对两种查询结果做统一抽象，避免ListView耦合不同的FetchResult类型，提供两种实现路径可选：

方案一：协议抽象（推荐，扩展性强） #

1. 定义通用数据结构和协议 #

// 统一的Section格式
struct ShopItemSection: Identifiable {
    let id: String
    let sectionTitle: String?
    let items: [ShopItem] // 替换为你自己的CoreData实体类名
}

// 列表数据统一适配协议
protocol ShopListDataProvider {
    var sectionList: [ShopItemSection] { get }
}

2. 给两种FetchResult做协议适配 #

// 适配普通无分区查询结果
extension FetchedResults<ShopItem>: ShopListDataProvider {
    var sectionList: [ShopItemSection] {
        // 无分区时返回只有1个无标题的Section
        [ShopItemSection(id: "no_section", sectionTitle: nil, items: Array(self))]
    }
}

// 适配分区查询结果，替换泛型为你自己的分区标识类型和实体类型
extension SectionedFetchResults<String, ShopItem>: ShopListDataProvider {
    var sectionList: [ShopItemSection] {
        self.map { systemSection in
            ShopItemSection(
                id: systemSection.id,
                sectionTitle: systemSection.id, // 可按需格式化展示的分区标题
                items: Array(systemSection)
            )
        }
    }
}

3. 改造ListView #

仅依赖通用协议，无需感知底层数据类型：

struct ListView: View {
    let data: ShopListDataProvider
    
    var body: some View {
        List {
            ForEach(data.sectionList) { section in
                if let title = section.sectionTitle {
                    Section(header: Text(title)) {
                        itemList(section.items)
                    }
                } else {
                    itemList(section.items)
                }
            }
        }
    }
    
    // 抽离公共的Item渲染逻辑
    private func itemList(_ items: [ShopItem]) -> some View {
        ForEach(items) { item in
            // 原有单条消费记录的Cell实现
        }
    }
}

4. 主视图动态切换数据源 #

struct MainView: View {
    @State private var enableSection = false
    @State private var sortDescriptors: [SortDescriptor<ShopItem>] = [.init(\.payTime, order: .reverse)]
    
    // 同时声明两种查询
    @FetchRequest private var plainList: FetchedResults<ShopItem>
    @SectionedFetchRequest<String, ShopItem> private var sectionedList: SectionedFetchResults<String, ShopItem>
    
    init() {
        // 初始化两种查询配置
        _plainList = FetchRequest(sortDescriptors: sortDescriptors)
        _sectionedList = SectionedFetchRequest(
            sectionIdentifier: \.shopName, // 替换为你需要分组的实体属性
            sortDescriptors: sortDescriptors
        )
    }
    
    var body: some View {
        NavigationStack {
            VStack(spacing: 0) {
                Toggle("按店铺分组", isOn: $enableSection)
                    .padding(.horizontal)
                ListView(data: enableSection ? sectionedList : plainList)
            }
            // 排序变更时同步更新两个查询的配置
            .onChange(of: sortDescriptors) { newDescriptors in
                plainList.sortDescriptors = newDescriptors
                sectionedList.sortDescriptors = newDescriptors
            }
        }
    }
}

方案二：轻量转换（适合小项目） #

不需要写协议，直接在父层把两种查询结果统一转换成[ShopItemSection]数组传给ListView即可：

// ListView直接接收转换后的数组
struct ListView: View {
    let sections: [ShopItemSection]
    // 渲染逻辑和方案一完全一致
}

// 父层动态计算传递的数组
struct MainView: View {
    // 省略查询声明、状态变量和初始化逻辑，和方案一一致
    private var displaySections: [ShopItemSection] {
        if enableSection {
            return sectionedList.map {
                ShopItemSection(id: $0.id, sectionTitle: $0.id, items: Array($0))
            }
        } else {
            return [ShopItemSection(id: "no_section", sectionTitle: nil, items: Array(plainList))]
        }
    }
    
    var body: some View {
        // 省略其他控件
        ListView(sections: displaySections)
    }
}

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