无法禁用SwiftUI视图更新？运行/单步模式切换遇问题

我的应用包含两种模式：

• 运行模式：快速执行，无需SwiftUI视图更新
• 单步模式：用户手动推进应用状态，每步都需视图更新

单步模式下SwiftUI视图更新正常，但运行模式中，我尝试通过实现Equatable协议禁用自动视图更新，编写了最小测试项目。按预期，CustomView的相等性判断始终返回true，视图不应更新，但实际仍会触发更新，无法理解原因。

补充说明：应用需要支持运行时切换两种模式，不能为不同模式重新构建应用。

测试代码 #

@Observable
final class Model {
    
    var counter = 0
    var timer = Timer()

    init() {
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
            self.counter += 1
        }
    }   
}

@main
struct ViewEquatableApp: App {
    
    let model = Model()
    
    var body: some Scene {
        WindowGroup {
            CustomView(model: model)
                .equatable()
        }
    }
}

struct CustomView: View, Equatable {
    let model: Model
    
    static func == (lhs: CustomView, rhs: CustomView) -> Bool {
        // << return yes on view properties which identifies that the
        // view is equal and should not be refreshed (ie. `body` is not rebuilt)
        true // <- true should disable the View update
    }
    
    var body: some View {
        ContentView(model: model)
    }
}

struct ContentView: View {
    let model: Model

    var body: some View {
        Text("Counter: \(model.counter)")
    }
}

问题原因 #

核心问题在于：@Observable对象的变化会直接触发所有引用它的子视图更新，父视图CustomView的Equatable判断无法阻止这种独立更新。

具体来说：

1. CustomView的Equatable仅控制自身是否需要重建body，但当Model的counter变化时，ContentView因为直接持有@Observable的Model实例，会被SwiftUI自动标记为需要更新，完全不受父视图的相等性判断影响。
2. 即使CustomView的body不重建，ContentView本身也会因为监听Model的变化而刷新。

解决方案 #

方案一：在子视图层面通过Equatable控制更新 #

给Model添加运行模式标记，让ContentView根据模式决定是否触发更新：

@Observable
final class Model {
    var counter = 0
    var timer = Timer()
    var isRunningMode = false // 新增：标记当前模式

    init() {
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
            self.counter += 1
        }
    }   
}

struct ContentView: View, Equatable {
    let model: Model

    static func == (lhs: ContentView, rhs: ContentView) -> Bool {
        // 运行模式下返回true，阻止更新；单步模式下比较counter值决定是否更新
        if lhs.model.isRunningMode {
            return true
        } else {
            return lhs.model.counter == rhs.model.counter
        }
    }

    var body: some View {
        Text("Counter: \(model.counter)")
    }
}

struct CustomView: View {
    let model: Model

    var body: some View {
        ContentView(model: model)
            .equatable() // 启用子视图的Equatable判断
    }
}

方案二：通过缓存显示值控制更新 #

在父视图中缓存需要显示的数值，仅在非运行模式下更新缓存：

@Observable
final class Model {
    var counter = 0
    var timer = Timer()
    var isRunningMode = false // 新增：标记当前模式

    init() {
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
            self.counter += 1
        }
    }   
}

struct CustomView: View {
    let model: Model
    @State private var displayedCounter = 0

    var body: some View {
        ContentView(counter: displayedCounter)
            .onChange(of: model.counter) { newValue in
                // 仅非运行模式下更新显示缓存
                if !model.isRunningMode {
                    displayedCounter = newValue
                }
            }
            .onAppear {
                displayedCounter = model.counter
            }
    }
}

struct ContentView: View {
    let counter: Int

    var body: some View {
        Text("Counter: \(counter)")
    }
}

两种方案都支持运行时切换模式，只需修改model.isRunningMode的值即可。

内容的提问来源于stack exchange，提问作者Reinhard Männer