SwiftData插入子记录后视图不更新问题求助

问题现象 #

使用SwiftData插入子记录时，数据库操作成功，但视图无法实时更新：

• 在DetailView中添加新Court记录后，ContentView里的tournament.title会更新为“Tournament with new court”，但tournament.courts.count始终显示为1，不会随新增记录增长
• DetailView中的List仅显示初始的Court，新增记录不展示
• 重启应用后，所有新增的Court都能正常显示，说明仅为视图层面的更新问题

相关代码 #

Tournament模型 #

@Model
final class Tournament {
    var title: String
    @Relationship(deleteRule: .cascade, inverse: \Court.tournament) var courts: [Court]
    
    init(title: String, courts: [Court] = []) {
        self.title = title
        self.courts = courts
    }
}

Court模型 #

@Model
final class Court {
    @Relationship var tournament: Tournament
    var number: Int
    
    init(tournament: Tournament, number: Int) {
        self.tournament = tournament
        self.number = number
    }
}

ContentView #

struct ContentView: View {
    @Environment(\.modelContext) private var modelContext
    @Query var tournaments: [Tournament]
    @State var selectedTournament: Tournament?
    
    var body: some View {
        NavigationSplitView {
            List(selection: $selectedTournament) {
                ForEach(tournaments) { tournament in
                    NavigationLink(value: tournament) {
                        HStack {
                            Text("\(tournament.title)")
                            Spacer()
                            Text("(\(tournament.courts.count))")
                        }
                    }
                }
            }
            .toolbar {
                ToolbarItem {
                    Button(action: {
                        addTournament()
                    }) {
                        Label("Add tournament", systemImage: "plus")
                    }
                }
            }
        } detail: {
            DetailView(tournament: selectedTournament)
        }
    }
    
    private func addTournament() {
        let newTournament = Tournament(title: "New tournament")
        modelContext.insert(newTournament)
        
        let court = Court(tournament: newTournament, number: 1)
        modelContext.insert(court)
        
        try? modelContext.save()
    }
}

DetailView #

struct DetailView: View {
    @Environment(\.modelContext) private var modelContext
    var tournament: Tournament?
    
    var body: some View {
        if let tournament {
            List {
                Section(tournament.title) {
                    ForEach(tournament.courts) { court in
                        Text("\(court.number)")
                    }
                }
            }
            Button {
                addCourt()
            } label: {
                Text("Add court")
            }
        } else {
            emptyView // ContentUnavailableView
        }
    }
    
    func addCourt() {
        if let tournament {
            let newCourt = Court(tournament: tournament, number: tournament.courts.count+1)
            modelContext.insert(newCourt)
        
            tournament.title = "Tournament with new court"
        
            try? modelContext.save()
        }
    }
}

用户临时解决方法 #

将关联属性改为可选类型后，视图能正常刷新：

修改后的Tournament模型 #

@Model
final class Tournament {
    var title: String
    @Relationship(deleteRule: .cascade, inverse: \Court.tournament) var courts: [Court]?
    // 其余代码不变
}

修改后的Court模型 #

@Model
final class Court {
    var tournament: Tournament?
    // 其余代码不变
}

问题原因与正确解决方案 #

核心原因 #

SwiftData对于非可选的集合关联（[Court]），默认不会自动触发父对象的视图更新通知。添加子对象Court时，父对象Tournament的courts集合发生变化，但SwiftData未向视图发送该对象已变更的信号，导致视图无法感知集合更新。而修改tournament.title时，因直接修改父对象属性，视图能更新，但集合变化未被捕获。

将关联改为可选类型后，SwiftData会将集合变更视为父对象属性变更，从而触发视图更新，但这并非最优解——业务逻辑中Tournament应始终拥有courts集合（哪怕是空的），无需设为可选。

正确解决方案 #

方案1：手动触发父对象的变更通知

添加Court后，调用modelContext.refresh(_:includingRelationships:)强制刷新父对象，触发视图更新：

func addCourt() {
    if let tournament {
        let newCourt = Court(tournament: tournament, number: tournament.courts.count+1)
        modelContext.insert(newCourt)
        
        // 手动刷新父对象，触发视图更新
        modelContext.refresh(tournament, includingRelationships: true)
        
        tournament.title = "Tournament with new court"
        try? modelContext.save()
    }
}

方案2：使用@Query监听子集合（针对DetailView）

在DetailView中，用@Query查询当前tournament关联的所有Court，让SwiftData自动监听集合变化并更新视图：

struct DetailView: View {
    @Environment(\.modelContext) private var modelContext
    var tournament: Tournament?
    // 使用@Query查询当前tournament的所有Court
    @Query private var courts: [Court]
    
    // 初始化时设置查询谓词
    init(tournament: Tournament?) {
        self.tournament = tournament
        _courts = Query(filter: #Predicate { $0.tournament == tournament })
    }
    
    var body: some View {
        if let tournament {
            List {
                Section(tournament.title) {
                    ForEach(courts) { court in
                        Text("\(court.number)")
                    }
                }
            }
            Button {
                addCourt()
            } label: {
                Text("Add court")
            }
        } else {
            ContentUnavailableView()
        }
    }
    
    func addCourt() {
        if let tournament {
            let newCourt = Court(tournament: tournament, number: courts.count + 1)
            modelContext.insert(newCourt)
        
            tournament.title = "Tournament with new court"
            try? modelContext.save()
        }
    }
}

可选集合生效的原理 #

当集合设为可选类型（[Court]?）时，添加子对象会改变该可选属性的引用（从非空集合变为新的非空集合，或从nil变为集合），SwiftData将此视为父对象的属性变更，从而触发视图更新机制。但这种方式违背业务语义，不推荐作为长期解决方案。

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