SwiftUI与CoreData：基于用户输入切换FetchedResults

核心结论 #

不能直接使用可变的@FetchRequest，因为@FetchRequest的参数（如entity）必须是编译时常量，无法通过@State等动态变量实时修改。

可行解决方案 #

1. 手动管理NSFetchedResultsController + ObservableObject #

通过手动创建NSFetchedResultsController，结合ObservableObject监听数据变化，实现动态切换实体的需求。

第一步：创建动态请求管理器

import SwiftUI
import CoreData

class DynamicFetchManager<T: NSManagedObject>: ObservableObject {
    @Published var results: [T] = []
    private var fetchedResultsController: NSFetchedResultsController<T>?
    private let context: NSManagedObjectContext

    init(context: NSManagedObjectContext, entity: NSEntityDescription, sortDescriptors: [NSSortDescriptor], predicate: NSPredicate?) {
        self.context = context
        updateFetchRequest(entity: entity, sortDescriptors: sortDescriptors, predicate: predicate)
    }

    // 切换实体的方法
    func switchEntity(to entity: NSEntityDescription, sortDescriptors: [NSSortDescriptor], predicate: NSPredicate?) {
        updateFetchRequest(entity: entity, sortDescriptors: sortDescriptors, predicate: predicate)
    }

    private func updateFetchRequest(entity: NSEntityDescription, sortDescriptors: [NSSortDescriptor], predicate: NSPredicate?) {
        guard let entityName = entity.name else { return }
        let fetchRequest = NSFetchRequest<T>(entityName: entityName)
        fetchRequest.sortDescriptors = sortDescriptors
        fetchRequest.predicate = predicate

        fetchedResultsController = NSFetchedResultsController(
            fetchRequest: fetchRequest,
            managedObjectContext: context,
            sectionNameKeyPath: nil,
            cacheName: nil
        )
        fetchedResultsController?.delegate = self

        do {
            try fetchedResultsController?.performFetch()
            results = fetchedResultsController?.fetchedObjects ?? []
        } catch {
            print("Fetch失败：\(error.localizedDescription)")
        }
    }
}

extension DynamicFetchManager: NSFetchedResultsControllerDelegate {
    func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
        guard let newResults = controller.fetchedObjects as? [T] else { return }
        results = newResults
    }
}

第二步：用协议统一重叠属性

因为两个实体有重叠属性（name、isUnlocked），定义一个协议来统一访问：

protocol UnlockedItem {
    var name: String? { get }
    var isUnlocked: Bool { get }
}

// 让两个实体遵守协议
extension CfColor: UnlockedItem {}
extension CfTexture: UnlockedItem {}

第三步：在视图中使用

struct ScrollGridView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @State private var currentEntityType: EntityType = .color

    // 定义枚举方便切换
    enum EntityType {
        case color, texture
    }

    // 初始化两个实体的请求管理器
    @StateObject private var colorManager = DynamicFetchManager<CfColor>(
        context: PersistenceController.shared.container.viewContext,
        entity: CfColor.entity(),
        sortDescriptors: [NSSortDescriptor(keyPath: \CfColor.name, ascending: true)],
        predicate: NSPredicate(format: "isUnlocked == 1")
    )

    @StateObject private var textureManager = DynamicFetchManager<CfTexture>(
        context: PersistenceController.shared.container.viewContext,
        entity: CfTexture.entity(),
        sortDescriptors: [NSSortDescriptor(keyPath: \CfTexture.name, ascending: true)],
        predicate: NSPredicate(format: "isUnlocked == 1")
    )

    var body: some View {
        VStack {
            // 切换按钮
            Button(currentEntityType == .color ? "切换到纹理" : "切换到颜色") {
                currentEntityType.toggle()
            }
            .padding()

            ScrollView {
                LazyVGrid(columns: [GridItem(.adaptive(minimum: 100))]) {
                    // 根据当前类型取对应数据，转成UnlockedItem统一处理
                    ForEach(getCurrentItems(), id: \.name) { item in
                        Text(item.name ?? "无名称")
                            .padding()
                            .background(Color.gray.opacity(0.2))
                            .cornerRadius(8)
                    }
                }
                .padding()
            }
        }
    }

    private func getCurrentItems() -> [UnlockedItem] {
        switch currentEntityType {
        case .color:
            return colorManager.results.map { $0 as UnlockedItem }
        case .texture:
            return textureManager.results.map { $0 as UnlockedItem }
        }
    }
}

// 给枚举加切换方法
extension ScrollGridView.EntityType {
    mutating func toggle() {
        self = self == .color ? .texture : .color
    }
}

2. 关于父类的选择 #

如果从业务建模角度，CfColor和CfTexture并不适合抽象为父子类，不建议强行创建父类。这种方式虽然能让@FetchRequest返回父类类型，但会引入不合理的继承关系，增加代码复杂度，违背设计原则。协议的方式更轻量、更灵活，完全能满足重叠属性的访问需求。

总结 #

• 动态修改@FetchRequest的实体参数不可行，因为属性包装器要求参数为编译时常量
• 最优方案是手动管理NSFetchedResultsController，结合ObservableObject实现动态切换
• 用协议统一重叠属性，避免类型判断的冗余代码
• 不要为了功能强行设计不合理的父类继承关系

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