SwiftUI ViewModifier中无法使用await关键字的解决方案咨询

为啥会出问题 #

1. Actor的所有属性访问都得用异步调用（await），但SwiftUI的body是同步计算的闭包，根本没法直接用await。
2. 让Actor直接继承ObservableObject本身就有问题——@Published的更新跨不过Actor的隔离边界，没法自动同步到主线程的View上。

解决办法：拆分数据源和业务逻辑 #

把状态管理和线程安全的业务逻辑分开：用一个跑在主线程的ObservableObject给View提供可观察状态，Actor专门处理需要线程安全的操作，两者通过异步调用同步状态。

修改后的完整代码：

// 专门处理线程安全业务逻辑的Actor
actor ActorLogic {
    static let shared = ActorLogic()
    private init() {}
    
    private var isActive: Bool = false
    
    func toggleActive() -> Bool {
        isActive.toggle()
        return isActive
    }
    
    func getCurrentState() -> Bool {
        return isActive
    }
}

// 主线程的ViewModel，负责给View提供可观察的状态
class ViewModel: ObservableObject {
    static let shared = ViewModel()
    private init() {}
    
    @Published var isActive: Bool = false
    private let logic = ActorLogic.shared
    
    func toggle() {
        Task {
            // 调用Actor的方法获取更新后的状态，切回主线程同步到@Published
            let newState = await logic.toggleActive()
            await MainActor.run {
                self.isActive = newState
            }
        }
    }
    
    func loadInitialState() {
        Task {
            let initialState = await logic.getCurrentState()
            await MainActor.run {
                self.isActive = initialState
            }
        }
    }
}

struct ContentView: View {
    var body: some View {
        VStack {
            ColorView()
            ButtonView()
        }
        .padding()
    }
}

struct ColorView: View {
    @ObservedObject private var viewModel = ViewModel.shared
    
    var body: some View {
        VStack {
            Rectangle()
                .foregroundStyle(viewModel.isActive ? .red : .blue) // 直接访问，不用await
                .frame(width: 100, height: 100)
        }
        .padding()
        .task {
            // 视图加载时初始化状态
            viewModel.loadInitialState()
        }
    }
}

struct ButtonView: View {
    @ObservedObject private var viewModel = ViewModel.shared
    
    var body: some View {
        VStack {
            Button("Toggle Color") {
                viewModel.toggle()
            }
        }
        .padding()
    }
}

另一种简化方案：直接把Actor状态同步到主线程 #

如果不想拆分两个Model，也可以让Actor在更新状态后主动把值同步到主线程的ViewModel：

actor ActorModel: @unchecked Sendable {
    static let shared = ActorModel()
    private init() {}
    
    private var isActive: Bool = false
    
    func toggleActive() {
        isActive.toggle()
        // 直接同步到主线程的ViewModel
        await MainActor.run {
            ViewModel.shared.isActive = isActive
        }
    }
    
    func getCurrentState() -> Bool {
        isActive
    }
}

class ViewModel: ObservableObject {
    static let shared = ViewModel()
    private init() {}
    
    @Published var isActive: Bool = false
    private let model = ActorModel.shared
    
    func loadInitialState() {
        Task {
            let state = await model.getCurrentState()
            await MainActor.run {
                isActive = state
            }
        }
    }
}

// 后面的ColorView和ButtonView用法和上面一致，用ViewModel做数据源

核心注意点 #

• 绝对不能在SwiftUI的body里用await，body是同步渲染的入口，必须快进快出。
• Actor的隔离性决定了所有访问都得异步，所以一定要通过主线程的ObservableObject给View提供状态，别让View直接碰Actor。
• 更新状态的时候必须用MainActor.run切回主线程，这样@Published才能正确触发View刷新。

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