如何在SwiftUI外修改SwiftData对象并实现持久化？

问题原因 #

1. 未显式保存上下文：SwiftData 的 ModelContext 不会自动持久化所有内存变更，必须显式调用 try modelContext.save() 才能将修改写入磁盘。
2. 跨上下文操作不一致：每次调用 AppSetting.appSetting 都会创建新的 PersistanceActor 实例，每个 Actor 持有独立的 ModelContext。修改对象后未在其所属上下文执行保存，导致变更仅停留在内存。
3. 修改逻辑未关联保存流程：直接修改对象属性后，没有触发任何保存操作，变更无法同步到持久化存储。

修复方案 #

1. 扩展 PersistanceActor，添加更新保存方法 #

在 Actor 内部封装修改和保存逻辑，确保操作与对应 ModelContext 绑定：

actor PersistanceActor: ModelActor {
    let modelContainer: ModelContainer
    let modelExecutor: any ModelExecutor
    
    init(modelContainer: ModelContainer) {
        self.modelContainer = modelContainer
        let context = ModelContext(modelContainer)
        modelExecutor = DefaultSerialModelExecutor(modelContext: context)
    }
    
    func save() {
        do {
            try modelContext.save()
        } catch {
            print("保存失败: \(error)")
        }
    }

    func insert<T:PersistentModel>(_ value:T) {
        do {
            modelContext.insert(value)
            try modelContext.save()
        } catch {
            print("插入失败: \(error)")
        }
    }
    
    func delete<T:PersistentModel>(_ value:T) {
        do {
            modelContext.delete(value)
            try modelContext.save()
        } catch {
            print("删除失败: \(error)")
        }
    }
    
    func get<T:PersistentModel>(_ descriptor:FetchDescriptor<T>)->[T]? {
        var toReturn:[T]?
        do {
            toReturn = try modelContext.fetch(descriptor)
        } catch {
            print("查询失败: \(error)")
        }
        return toReturn
    }
    
    // 新增更新方法：在上下文内修改并保存对象
    func update<T: PersistentModel>(_ value: T, updateHandler: (inout T) throws -> Void) {
        do {
            var mutableValue = value
            try updateHandler(&mutableValue)
            try modelContext.save()
        } catch {
            print("更新失败: \(error)")
        }
    }
}

2. 修改 AppDelegate 的存储逻辑 #

通过 Actor 的 update 方法执行修改操作，确保变更被正确保存：

extension AppDelegate {
    func storeValue(name: String) async {
        print("准备存储新名称: \(name)")
        
        let actor = PersistanceActor(modelContainer: Persistance.sharedModelContainer)
        if let appSetting = await actor.get(AppSetting.allFD)?.first {
            // 通过Actor修改并保存对象
            await actor.update(appSetting) { $0.name = "从AppDelegate存储的值" }
        } else {
            // 不存在则创建插入
            let newVal = AppSetting(name: "new value")
            await actor.insert(newVal)
        }
        
        // 验证修改结果
        if let apps2 = await actor.get(AppSetting.allFD)?.first {
            print("修改后存储的AppSetting值: \(apps2.name)")
        }
    }
}

3. 优化 AppSetting 获取逻辑 #

确保对象获取与操作使用一致的上下文：

@Model
class AppSetting {
    var name:String
    
    init(name: String) {
        self.name = name
    }
    
    init() {
        self.name="init"
    }
    
    private class func getAppSetting() async -> AppSetting? {
        let actor = PersistanceActor(modelContainer: Persistance.sharedModelContainer)
        return await actor.get(AppSetting.allFD)?.first
    }
    
    static var appSetting: AppSetting {
        get async {
            if let found = await getAppSetting() {
                return found
            } else {
                let newVal = AppSetting(name: "new value")
                let actor = PersistanceActor(modelContainer: Persistance.sharedModelContainer)
                await actor.insert(newVal)
                return newVal
            }
        }
    }
}

关键修复点 #

• 所有数据操作（增删改查）都通过 PersistanceActor 执行，确保上下文一致性。
• 修改对象时必须通过 Actor 的 update 方法触发保存，避免跨上下文的无效修改。
• 每次数据变更后显式调用 modelContext.save()，保证内存中的修改同步到持久化存储。

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