SwiftUI视图未更新：基于@Published对象数组的计算属性绑定问题

你遇到的核心问题是：当修改@Published数组中引用类型（比如Task如果是class）的属性时，SwiftUI不会自动触发视图更新。这是因为@Published的数组只有在数组本身被替换（比如重新赋值）或者数组的元素是值类型且被修改时，才会发送objectWillChange通知。而如果Task是class，修改它的属性并不会改变数组中元素的引用，所以StateController不会发出更新信号，依赖计算属性allTasks的视图也就不会刷新。

另外，你的几个统计计算属性（比如numberofCompletedTasks）存在逻辑错误：map返回的是布尔值数组，count得到的是数组长度，而不是符合条件的任务数量，需要修正。

根据你的需求，推荐两种方案，优先选择值类型方案，因为它更符合SwiftUI的设计理念，也更简单可靠。

方案1：将Task和Subject改为值类型（Struct） #

SwiftUI对值类型的变化感知更直接，当值类型的属性被修改时，数组会被视为“变化”，从而触发@Published的更新通知。

步骤1：重构Task和Subject为Struct #

// 改为Identifiable的Struct
struct Task: Identifiable {
    let taskID: UUID
    var isCompleted: Bool
    var priority: Int
    // 其他属性根据你的需求添加
    
    init(taskID: UUID = UUID(), isCompleted: Bool = false, priority: Int = 2) {
        self.taskID = taskID
        self.isCompleted = isCompleted
        self.priority = priority
    }
}

struct Subject: Identifiable {
    let id: UUID
    var tasks: [Task]
    // 其他属性根据你的需求添加
    
    init(id: UUID = UUID(), tasks: [Task] = []) {
        self.id = id
        self.tasks = tasks
    }
}

步骤2：修正StateController中的计算属性和添加修改方法 #

首先修复统计属性的逻辑错误，然后添加修改任务的方法（因为值类型不能直接修改数组内的元素，需要创建新实例替换）：

class StateController: ObservableObject {
    @Published var subjects: [Subject]
    private let storageController = StorageController()

    init() {
        self.subjects = storageController.fetchData()
    }
    
    // 修正后的计算属性
    var allTasks: [Task] {
        let all = subjects.flatMap { $0.tasks }
        print("Computed property updated!")
        return all
    }
    
    var numberOfCompletedTasks: Int {
        allTasks.filter { $0.isCompleted }.count
    }
    
    var numberOfHighPriorityTasks: Int {
        allTasks.filter { $0.priority == 1 }.count
    }
    
    var numberOfMediumPriorityTasks: Int {
        allTasks.filter { $0.priority == 2 }.count
    }
    
    var numberOfLowPriorityTasks: Int {
        allTasks.filter { $0.priority == 3 }.count
    }
    
    // 添加修改任务完成状态的方法
    func toggleTaskCompletion(for taskID: UUID) {
        // 遍历找到对应的Subject和Task，创建新实例替换
        subjects = subjects.map { subject in
            var updatedSubject = subject
            updatedSubject.tasks = updatedSubject.tasks.map { task in
                guard task.taskID == taskID else { return task }
                var updatedTask = task
                updatedTask.isCompleted.toggle()
                return updatedTask
            }
            return updatedSubject
        }
    }
    
    // 可以根据需求添加其他修改方法，比如修改优先级、添加/删除任务等
}

步骤3：在视图中使用修改方法 #

在TaskView中，通过EnvironmentObject调用StateController的方法来修改任务，而不是直接修改Task的属性：

struct TaskView: View {
    let task: Task
    @EnvironmentObject private var stateController: StateController
    
    var body: some View {
        HStack {
            Button(action: {
                stateController.toggleTaskCompletion(for: task.taskID)
            }) {
                Image(systemName: task.isCompleted ? "checkmark.circle.fill" : "circle")
            }
            Text(task.title) // 假设Task有title属性
            // 其他UI元素
        }
    }
}

这样，当你点击按钮修改任务状态时，StateController会生成新的Task和Subject实例，替换subjects数组中的元素，触发@Published的更新通知，计算属性allTasks会重新计算，视图也会自动刷新。

方案2：保持引用类型（Class），手动监听变化 #

如果必须使用class类型的Task和Subject，需要让它们也遵循ObservableObject，并让StateController监听它们的变化，手动发送更新信号。

步骤1：让Task和Subject遵循ObservableObject #

class Task: ObservableObject, Identifiable {
    let taskID: UUID
    @Published var isCompleted: Bool
    @Published var priority: Int
    // 其他属性
    
    init(taskID: UUID = UUID(), isCompleted: Bool = false, priority: Int = 2) {
        self.taskID = taskID
        self.isCompleted = isCompleted
        self.priority = priority
    }
}

class Subject: ObservableObject, Identifiable {
    let id: UUID
    @Published var tasks: [Task]
    // 其他属性
    
    init(id: UUID = UUID(), tasks: [Task] = []) {
        self.id = id
        self.tasks = tasks
    }
}

步骤2：在StateController中监听所有子对象的变化 #

class StateController: ObservableObject {
    @Published var subjects: [Subject]
    private let storageController = StorageController()
    private var cancellables = Set<AnyCancellable>()

    init() {
        self.subjects = storageController.fetchData()
        // 监听subjects数组的变化，以及每个subject和task的变化
        setupSubscriptions()
    }
    
    private func setupSubscriptions() {
        cancellables.removeAll()
        
        // 监听subjects数组的变化
        $subjects
            .sink { [weak self] newSubjects in
                self?.subscribeToSubjects(newSubjects)
            }
            .store(in: &cancellables)
    }
    
    private func subscribeToSubjects(_ subjects: [Subject]) {
        subjects.forEach { subject in
            // 监听subject的变化
            subject.objectWillChange
                .sink { [weak self] _ in
                    self?.objectWillChange.send()
                }
                .store(in: &cancellables)
            
            // 监听subject中tasks数组的变化
            subject.$tasks
                .sink { [weak self] newTasks in
                    self?.subscribeToTasks(newTasks)
                }
                .store(in: &cancellables)
        }
    }
    
    private func subscribeToTasks(_ tasks: [Task]) {
        tasks.forEach { task in
            // 监听task的变化
            task.objectWillChange
                .sink { [weak self] _ in
                    self?.objectWillChange.send()
                }
                .store(in: &cancellables)
        }
    }
    
    // 修正后的计算属性（同方案1）
    var allTasks: [Task] {
        let all = subjects.flatMap { $0.tasks }
        print("Computed property updated!")
        return all
    }
    
    var numberOfCompletedTasks: Int {
        allTasks.filter { $0.isCompleted }.count
    }
    
    // 其他统计属性...
}

这种方案可以在修改Task的属性时触发视图更新，但需要维护较多的订阅逻辑，容易出现内存泄漏或漏监听的情况，所以仅在必须使用引用类型时考虑。

优先选择值类型方案，它更符合SwiftUI的响应式设计，代码更简洁可靠。同时注意：

• 不要直接修改数组内值类型的属性，必须通过创建新实例替换的方式更新数组
• 确保所有修改操作都通过StateController的方法完成，这样才能触发@Published的更新通知

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