我完全懂你的痛点——用@Query虽然能自动同步数据库变更，但没法灵活控制加载状态、错误处理这些细节；自己手动实现fetch逻辑后，又得操心数据库变了怎么自动刷新数据，总不能在每个insert/delete的地方都加一遍刷新代码吧？

刚好SwiftData本身提供了两种优雅的方式来解决这个问题，不需要你到处埋刷新逻辑，下面给你详细说：

方案一：用ModelPublisher监听实体变化（SwiftData原生API） #

这是最贴合SwiftData设计的方案，专门用来监听指定实体的增删改变化，类型安全还不用依赖Core Data的老通知。

修改你的ViewModel #

我们在ViewModel里添加一个监听任务，当Item实体有任何变化时，自动重新执行加载逻辑：

import SwiftUI
import SwiftData
import Combine

@Observable class ItemListViewModel {
    enum State {
        case idle
        case loading
        case failed(Error)
        case loaded([ItemView])
    }
    
    private(set) var state = State.idle
    private var currentPredicate: Predicate<Item>? // 保存当前查询条件，刷新时复用
    private var changeListeningTask: Task<Void, Never>? // 用来管理监听任务的生命周期
    
    func fetchData(container: ModelContainer, predicate: Predicate<Item>) async throws -> [ItemView] {
        let service = ThreadsafeBackgroundActor(modelContainer: container)
        return try await service.fetchData(predicate)
    }
    
    @MainActor func load(container: ModelContainer, predicate: Predicate<Item>) async {
        currentPredicate = predicate // 存下当前的查询条件
        state = .loading
        do {
            try await Task.sleep(for: .seconds(1))
            let items = try await fetchData(container: container, predicate: predicate)
            state = .loaded(items)
        } catch is CancellationError {
            state = .idle
        } catch {
            state = .failed(error)
        }
    }
    
    // 新增：设置实体变化监听
    func setupEntityChangeListener(container: ModelContainer) {
        // 先取消之前的监听任务，避免重复监听
        changeListeningTask?.cancel()
        
        changeListeningTask = Task { [weak self] in
            // 监听容器中所有Item实体的变化
            for await _ in ModelPublisher(for: Item.self, in: container)
                .debounce(for: .milliseconds(200), scheduler: DispatchQueue.main) { // 防抖，避免频繁刷新
                guard let self = self, let predicate = self.currentPredicate else { continue }
                // 切换到主线程触发重新加载
                await MainActor.run {
                    Task {
                        await self.load(container: container, predicate: predicate)
                    }
                }
            }
        }
    }
    
    // 销毁时取消任务，防止内存泄漏
    deinit {
        changeListeningTask?.cancel()
    }
}

在视图中启用监听 #

在你的ContentView里，只要在初始加载时调用一次监听设置即可：

struct ContentView: View {
    @State private var viewModel = ItemListViewModel()
    @Environment(\.modelContext) private var modelContext
    @State private var refreshCount = 0
    
    var body: some View {
        NavigationSplitView {
            // 原有的视图内容保持不变...
        }
        .task(id: refreshCount) {
            let predicate = #Predicate<Item> { _ in true }
            await viewModel.load(container: modelContext.container, predicate: predicate)
            // 启动实体变化监听
            viewModel.setupEntityChangeListener(container: modelContext.container)
        }
    }
    
    // 原有的addItem等方法保持不变...
}

方案二：监听ModelContext的保存通知（兼容Core Data习惯） #

如果你更习惯用通知中心的方式，SwiftData的ModelContext底层还是基于Core Data的，所以可以监听经典的NSManagedObjectContextDidSave通知，只要任何上下文保存了变更，就触发刷新：

修改ViewModel #

import SwiftUI
import SwiftData
import Combine

@Observable class ItemListViewModel {
    // 原有的State、state属性不变...
    private var currentPredicate: Predicate<Item>?
    private var cancellables = Set<AnyCancellable>() // 保存订阅，防止内存泄漏
    
    // 原有的fetchData、load方法不变（记得在load里保存currentPredicate）...
    
    // 新增：设置保存通知监听
    func setupSaveNotificationListening() {
        NotificationCenter.default.publisher(for: NSNotification.Name.NSManagedObjectContextDidSave)
            .receive(on: DispatchQueue.main)
            .debounce(for: .milliseconds(200), scheduler: DispatchQueue.main) // 防抖优化
            .sink { [weak self] _ in
                guard let self = self, 
                      let predicate = self.currentPredicate,
                      let container = self.currentContainer else { return }
                Task {
                    await self.load(container: container, predicate: predicate)
                }
            }
            .store(in: &cancellables)
    }
    
    // 可以额外存一下当前的container，避免每次都传
    private var currentContainer: ModelContainer?
    // 修改load方法，顺便保存container
    @MainActor func load(container: ModelContainer, predicate: Predicate<Item>) async {
        currentPredicate = predicate
        currentContainer = container
        // 原有的load逻辑不变...
    }
}

视图中启用监听 #

和方案一一样，在ContentView的task里调用setupSaveNotificationListening()即可。

关键注意点 #

1. 防抖处理：不管用哪种方案，都加了debounce，避免短时间内批量操作（比如批量插入10条数据）导致频繁触发刷新，影响性能。
2. 状态复用：必须保存当前的predicate和container，这样刷新时才能用和之前完全一致的条件重新拉取数据，保证内容的一致性。
3. 内存泄漏：方案一用Task+deinit取消，方案二用AnyCancellable存订阅，都是为了避免ViewModel被意外持有导致内存泄漏。

这两个方案都不需要你在每个insert/delete的地方手动加刷新代码，完全符合你“让SwiftData自己干活，少写冗余代码”的需求。

内容来源于stack exchange