如何在ViewModel中使用SectionedFetchRequest？

1. 能否在ViewModel中使用SectionedFetchRequest属性包装器？ #

不能直接在ViewModel中使用@SectionedFetchRequest。SectionedFetchRequest是SwiftUI专属的属性包装器，它依赖SwiftUI视图环境（尤其是managedObjectContext）来工作，并且仅能在View结构体或ViewModifier中使用。ViewModel作为ObservableObject，不属于SwiftUI的视图层级，无法获取所需的环境上下文，因此无法直接使用该属性包装器。

2. Core Data是否有分段获取数据的等效方法？ #

Core Data没有直接对应SectionedFetchRequest的分段fetch API，但可以通过两种方式实现分段数据管理：

方案一：使用NSFetchedResultsController（推荐）

NSFetchedResultsController是Core Data提供的用于管理分页、分段数据的控制器，支持自动监听数据变化并更新，适合大数据量场景。可以在ViewModel中集成它，将分段结果通过@Published发布给视图。

修改后的ViewModel代码：

import CoreData
import SwiftUI

class MyTypeViewModel: ObservableObject {
    @Published var sections: [Section<String?, MyType>] = []
    private let context: NSManagedObjectContext
    private var fetchedResultsController: NSFetchedResultsController<MyType>?

    // 自定义分段模型，用于传递给视图
    struct Section<ID, Element> {
        let id: ID
        let elements: [Element]
    }

    init(context: NSManagedObjectContext, sortDescriptors: [SortDescriptor<MyType>], filter: String) {
        self.context = context
        setupFetchedResultsController(sortDescriptors: sortDescriptors, filter: filter)
        fetchSections()
    }

    private func setupFetchedResultsController(sortDescriptors: [SortDescriptor<MyType>], filter: String) {
        let request = NSFetchRequest<MyType>(entityName: "MyType")
        request.sortDescriptors = sortDescriptors
        request.predicate = filter.isEmpty ? nil : NSPredicate(format: "title CONTAINS[cd] %@", filter)

        // 通过sectionNameKeyPath指定分段依据
        fetchedResultsController = NSFetchedResultsController(
            fetchRequest: request,
            managedObjectContext: context,
            sectionNameKeyPath: #keyPath(MyType.title),
            cacheName: nil
        )
        fetchedResultsController?.delegate = self
    }

    private func fetchSections() {
        do {
            try fetchedResultsController?.performFetch()
            updateSections()
        } catch {
            print("DEBUG: Fetch error - \(error.localizedDescription)")
        }
    }

    private func updateSections() {
        guard let controllerSections = fetchedResultsController?.sections else {
            sections = []
            return
        }
        sections = controllerSections.map { section in
            Section(
                id: section.name as String?,
                elements: section.objects as? [MyType] ?? []
            )
        }
    }

    // 提供更新筛选条件或排序规则的方法
    func update(filter: String, sortDescriptors: [SortDescriptor<MyType>]) {
        setupFetchedResultsController(sortDescriptors: sortDescriptors, filter: filter)
        fetchSections()
    }
}

// 监听Core Data数据变化，自动更新分段数据
extension MyTypeViewModel: NSFetchedResultsControllerDelegate {
    func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
        updateSections()
    }
}

对应的视图代码：

struct FilteredSectionedListView: View {
    @Environment(\.managedObjectContext) private var context
    @StateObject private var viewModel: MyTypeViewModel

    init(descriptor: [SortDescriptor<MyType>], filter: String) {
        _viewModel = StateObject(wrappedValue: MyTypeViewModel(
            context: context,
            sortDescriptors: descriptor,
            filter: filter
        ))
    }

    var body: some View {
        List {
            ForEach(viewModel.sections) { section in
                Section(header: Text(section.id ?? "Unknown")) {
                    ForEach(section.elements) { myType in
                        Text("\(myType.category ?? "")")
                    }
                }
            }
        }
    }
}

方案二：手动分组普通Fetch结果（适合小数据量）

如果数据量不大，可以先执行普通的NSFetchRequest，再通过Swift标准库的Dictionary(grouping:)方法手动分组，转换成分段结构。

ViewModel中的手动分组实现：

func fetchAndGroupMyTypes(filter: String) {
    let request = NSFetchRequest<MyType>(entityName: "MyType")
    request.sortDescriptors = [SortDescriptor(\.title)]
    request.predicate = filter.isEmpty ? nil : NSPredicate(format: "title CONTAINS[cd] %@", filter)
    
    do {
        let allMyTypes = try context.fetch(request)
        // 按title分组
        let grouped = Dictionary(grouping: allMyTypes, by: { $0.title })
        // 转换成有序的分段数组
        sections = grouped.sorted(by: { $0.key ?? "" < $1.key ?? "" }).map { key, elements in
            Section(id: key, elements: elements)
        }
    } catch {
        print("DEBUG: Fetch error - \(error.localizedDescription)")
    }
}

这种方式实现简单，但需要手动处理数据更新（比如监听上下文变化、在数据修改后重新调用分组方法）。

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