如何在UIViewRepresentable中监听多个状态变化？

当需要在UIViewRepresentable中监听多个状态变化时，逐个添加@State绑定和.onChange修饰符的方式会导致代码冗余且扩展性差。推荐通过统一状态模型封装+Combine监听的方案解决，以下是具体实现步骤：

1. 创建统一的状态模型 #

将所有需要监听的属性集中到一个可观察对象类中，用@Published标记需要监听的属性（iOS17+可改用@Observable简化代码）：

// iOS 13+ 版本
class GameState: ObservableObject {
    @Published var userWon: Bool = false
    @Published var propA: Bool = false
    @Published var propB: Int = 0
    @Published var propC: Int = 0
    // 新增属性直接在这里添加即可
    @Published var propZ: Int = 0
}

// iOS 17+ 简化版本（无需手动加@Published）
@Observable
class GameState {
    var userWon: Bool = false
    var propA: Bool = false
    var propB: Int = 0
    var propC: Int = 0
    var propZ: Int = 0
}

2. 在GameService中监听状态变化 #

让GameService持有GameState实例，通过Combine框架监听属性变化，将状态响应逻辑内聚到服务层，避免在View中写大量.onChange：

class GameService: ObservableObject {
    private var cancellables = Set<AnyCancellable>()
    private let gameState: GameState
    
    init(gameState: GameState) {
        self.gameState = gameState
        setupStateListeners()
    }
    
    private func setupStateListeners() {
        // 监听userWon（仅在变为true时触发）
        gameState.$userWon
            .filter { $0 }
            .sink { [weak self] _ in
                self?.updateUserScore()
            }
            .store(in: &cancellables)
        
        // 监听propA变化
        gameState.$propA
            .sink { [weak self] newValue in
                self?.doSomethingA(with: newValue)
            }
            .store(in: &cancellables)
        
        // 监听propB变化
        gameState.$propB
            .sink { [weak self] newValue in
                self?.doSomethingB(with: newValue)
            }
            .store(in: &cancellables)
        
        // 新增属性时，在这里添加对应的监听逻辑即可
        gameState.$propZ
            .sink { [weak self] newValue in
                self?.doSomethingZ(with: newValue)
            }
            .store(in: &cancellables)
    }
    
    // 业务逻辑示例
    func updateUserScore() {
        // 处理用户获胜后的分数更新
    }
    
    func doSomethingA(with value: Bool) {
        // 处理propA变化的业务逻辑
    }
    
    func doSomethingB(with value: Int) {
        // 处理propB变化的业务逻辑
    }
    
    func doSomethingZ(with value: Int) {
        // 处理propZ变化的业务逻辑
    }
}

3. 修改SwiftUI View，传递状态模型 #

在GameView中用@StateObject持有GameState，并将其注入GameService，无需再定义多个零散的@State属性：

struct GameView: View {
    @StateObject private var gameState = GameState()
    @StateObject private var gameService: GameService
    
    // 初始化时注入gameState到gameService
    init() {
        _gameService = StateObject(wrappedValue: GameService(gameState: gameState))
    }
    
    var body: some View {
        ZStack {
            VStack {
                // 仅传递gameState给Representable
                GameViewRepresentable(gameState: gameState)
            }
            .clipped()
        }
    }
}

4. 优化UIViewRepresentable和Coordinator #

让Representable接收GameState实例，Coordinator直接操作状态模型更新属性，无需多个绑定参数：

struct GameViewRepresentable: UIViewRepresentable {
    typealias UIViewType = GameView
    let gameState: GameState
    
    func makeUIView(context: Context) -> GameView {
        let gameView = GameView()
        gameView.delegate = context.coordinator
        return gameView
    }

    func updateUIView(_ uiView: GameView, context: Context) {
        // 如果需要从SwiftUI向UIView同步状态，在这里处理
        // 例如：uiView.refreshUI(with: gameState)
    }

    func makeCoordinator() -> GameViewCoordinator {
        GameViewCoordinator(gameState: gameState)
    }

    class GameViewCoordinator: GameViewDelegate  {
        private let gameState: GameState
        
        init(gameState: GameState) {
            self.gameState = gameState
        }

        func userWon() {
            gameState.userWon = true
        }
        
        // 新增代理方法时，直接更新gameState对应的属性
        func didUpdatePropA(to value: Bool) {
            gameState.propA = value
        }
        
        func didUpdatePropB(to value: Int) {
            gameState.propB = value
        }
        
        // ... 其他代理方法
    }
}

方案优势 #

• 状态集中管理：所有需要监听的属性统一在GameState中，结构清晰，避免零散的@State。
• 逻辑内聚：状态变化的响应逻辑都放在GameService中，View只负责展示和传递状态，符合单一职责原则。
• 扩展性强：新增属性时，仅需修改GameState和GameService，无需修改View和Representable的参数列表。
• 代码简洁：省去大量冗余的.onChange修饰符和绑定参数。

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