SwiftUI中如何基于Swift Data查询结果生成Player状态数组？

一、核心思路：分离持久化模型与业务状态 #

Swift Data 的 GamePlayer 作为持久化模型，仅负责存储玩家的核心数据（如名称、ID），不适合直接持有 Stopwatch 这类临时运行状态对象。我们需要在其之上封装一层业务对象（保留原有的 Player 类），用来关联 GamePlayer 和 Stopwatch，同时统一管理秒表的启停逻辑。

二、具体实现步骤 #

1. 定义业务层 Player 类 #

class Player: ObservableObject {
    let gamePlayer: GamePlayer // 关联Swift Data持久化模型
    @Published var stopwatch: Stopwatch // 秒表实例
    
    init(gamePlayer: GamePlayer) {
        self.gamePlayer = gamePlayer
        self.stopwatch = Stopwatch()
        // 可选：从持久化模型读取秒表初始状态（如需重启后保留进度）
        if let elapsed = gamePlayer.elapsedTime {
            stopwatch.elapsedTime = elapsed
        }
    }
    
    // 封装秒表操作方法，同步状态到持久化模型
    func toggleStopwatch() {
        stopwatch.toggle()
        syncElapsedTime()
    }
    
    func startStopwatch() {
        stopwatch.start()
        syncElapsedTime()
    }
    
    func stopStopwatch() {
        stopwatch.stop()
        syncElapsedTime()
    }
    
    private func syncElapsedTime() {
        gamePlayer.elapsedTime = stopwatch.elapsedTime
        try? gamePlayer.modelContext?.save()
    }
}

2. 父视图中管理 Player 数组与批量操作 #

通过 @Query 获取 GamePlayer 列表，转换成 Player 数组并保持同步，同时处理编辑模式下的批量操作：

struct PlayerListView: View {
    @Query(sort: \GamePlayer.name) private var gamePlayers: [GamePlayer]
    @State private var players: [Player] = []
    @State private var selectedPlayers: Set<Player> = []
    @Environment(\.editMode) private var editMode
    
    var body: some View {
        List(players, selection: $selectedPlayers) { player in
            PlayerRowView(player: player)
                .swipeActions {
                    Button(player.stopwatch.isRunning ? "停止" : "启动") {
                        player.toggleStopwatch()
                    }
                }
        }
        .toolbar {
            if editMode?.wrappedValue.isEditing == true {
                Button("批量启动") {
                    selectedPlayers.forEach { $0.startStopwatch() }
                }
                Button("批量停止") {
                    selectedPlayers.forEach { $0.stopStopwatch() }
                }
            }
        }
        // 监听Swift Data数据变化，同步业务层Player数组
        .onReceive(gamePlayers.publisher) { newGamePlayers in
            syncPlayers(with: newGamePlayers)
        }
        .onAppear {
            // 初始加载时生成Player数组
            players = gamePlayers.map(Player.init)
        }
    }
    
    private func syncPlayers(with newGamePlayers: [GamePlayer]) {
        let currentGamePlayerIDs = Set(players.map { $0.gamePlayer.id })
        let newGamePlayerIDs = Set(newGamePlayers.map { $0.id })
        
        // 添加新玩家对应的Player实例
        let newPlayers = newGamePlayers.filter { !currentGamePlayerIDs.contains($0.id) }
            .map(Player.init)
        players.append(contentsOf: newPlayers)
        
        // 移除已删除玩家对应的Player实例
        players.removeAll { !newGamePlayerIDs.contains($0.gamePlayer.id) }
    }
}

3. 子视图 PlayerRowView 展示玩家与秒表状态 #

struct PlayerRowView: View {
    @ObservedObject var player: Player
    
    var body: some View {
        HStack {
            Text(player.gamePlayer.name)
            Spacer()
            Text(player.stopwatch.elapsedTimeFormatted) // 假设Stopwatch提供格式化时间的属性
                .font(.caption)
            if player.stopwatch.isRunning {
                Image(systemName: "stopwatch.fill")
            }
        }
    }
}

三、方案合理性分析 #

优点 #

• 职责清晰：GamePlayer 专注持久化，Player 专注业务逻辑与临时状态，符合单一职责原则，避免持久化模型与业务逻辑耦合。
• 操作可控：父视图通过 selectedPlayers 直接访问 Player 的秒表方法，批量操作逻辑直观，无需绕持久化层。
• 数据同步可靠：通过 onReceive 监听 GamePlayer 列表变化，确保业务层数组与数据库数据实时同步。

注意事项 #

• 内存管理：Player 作为 ObservableObject，SwiftUI 会自动管理视图对其的引用，无需额外处理内存泄漏，但需避免在非视图场景中持有不必要的强引用。
• 状态持久化：如果需要秒表状态在APP重启后保留，必须在 Player 的操作方法中同步 elapsedTime 到 GamePlayer 并保存上下文，否则秒表状态仅为内存临时数据。
• 性能优化：当玩家数量较大时，syncPlayers 方法可引入Diff算法，减少不必要的数组操作，提升同步效率。

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