SwiftUI - 带有绑定的@State 属性结构不会导致重绘

Question

以下是我绘制 SwiftUI 视图的代码，该视图使用发布者获取需要在列表中绘制的项目。这些项目都具有使用Toggle 绘制的布尔值。

我的视图是愚蠢的，所以我可以使用任何类型的布尔值，也许支持 UserDefaults、支持核心数据，或者只是某个地方的布尔属性......无论如何，当在视图之外更新布尔值时，这不会重绘其中一个布尔值已更新。 onReceive 被调用，我可以在控制台中看到输出更改，但绑定不是我的 ToggleItem 结构的一部分，因此 SwiftUI 不会重绘。

我的代码...

我有一个类似这样的结构，注意这里的绑定类型...

struct ToggleItem: Identifiable, Equatable {
    let id: String
    let name: String
    let isOn: Binding<Bool>

    public static func == (lhs: ToggleItem, rhs: ToggleItem) -> Bool {
        lhs.id == rhs.id
    }
}

在我的 SwiftUI 中，我有这个...

struct MyView: View {
    @State private var items: [ToggleItem] = []
    
    let itemsPublisher: AnyPublisher<[ToggleItem], Never>

    // ...

    var body: some View {
        List {

        // ...
        
        }
        .onReceive(itemsPublisher) { newItems in
            print("New items: \(newItems)")
            items.removeAll() // hacky redraw
            items = newItems
       }
}

我可以看到这里发生了什么，因为 Binding<Bool> 不是一个值，所以 SwiftUI 看到 newItems 的数组等于它已经绘制的 items，因此，这不会重绘。

我是否缺少一些东西，也许是一些巧妙的 SwiftUI/Combine 为我重绘了这个？

Answer 1

不如做这样的事情来保持一个真实的来源：

struct ToggleItem: Identifiable, Equatable {
    let id: String
    let name: String
    var isOn: Bool

    public static func == (lhs: ToggleItem, rhs: ToggleItem) -> Bool {
        lhs.id == rhs.id
    }
}

class ItemsPublisher: ObservableObject {
    @Published var items: [ToggleItem] = [ToggleItem(id: "1", name: "name1", isOn: false)]  // for testing
}

struct ContentView: View {
    @ObservedObject var itemsPublisher = ItemsPublisher()  // to be passed in from parent
    
    var body: some View {
        VStack {
            Button("Add item") {
                let randomString = UUID().uuidString
                let randomBool = Bool.random()
                itemsPublisher.items.append(ToggleItem(id: randomString, name: randomString, isOn: randomBool))
            }
            List ($itemsPublisher.items) { $item in
                Toggle(isOn: $item.isOn) {
                    Text(item.name)
                }
            }
            Spacer()
        }.padding(.top, 50)
        .onReceive(itemsPublisher.items.publisher) { newItem in
            print("----> new item: \(newItem)")
        }
    }
}

Answer 2

似乎删除绑定是正确的前进方向！

现在看一下文档，这很有意义https://developer.apple.com/documentation/swiftui/binding

使用绑定在存储数据的属性与显示和更改数据的视图之间创建双向连接。

虽然不明确，但这确实表明绑定“属性包装器”仅用作 SwiftUI 视图中的属性，而不是数据模型。

我的更改

我在视图中添加了一个闭包

let itemDidToggle: (ToggleItem, Bool) -> Void

这在 Toggle 绑定的 set() 函数中被调用，该函数更新视图外部的值，使视图保持不变。这会触发发布者被调用并更新我的堆栈。再加上更新 == equatable 函数以包含 isOn 属性，一切正常......

我的代码

导入 UIKit 导入游乐场支持 进口组合 导入 SwiftUI

public struct MyItem {
    public let identifier: String
    public let description: String
}

public class ItemsManager {
    public private(set) var items: [MyItem]
    public let itemsPublisher: CurrentValueSubject<[MyItem], Never>
    private let userDefaults: UserDefaults

    public init(items: [MyItem], userDefaults: UserDefaults = .standard) {
        self.userDefaults = userDefaults
        self.items = items
        self.itemsPublisher = .init(items)
    }
    
    public func isItemEnabled(identifier: String) -> Bool {
        guard let item = item(for: identifier) else {
            return false
        }

        if let isOnValue = userDefaults.object(forKey: item.identifier) as? NSNumber {
            return isOnValue.boolValue
        } else {
            return false
        }
    }
    
    public func setEnabled(_ isEnabled: Bool, forIdentifier identifier: String) {
        userDefaults.set(isEnabled, forKey: identifier)
        
        itemsPublisher.send(items)
    }

    func item(for identifier: String) -> MyItem? {
        return items.first { $0.identifier == identifier }
    }

}

struct MyView: View {
    @State private var items: [ToggleItem] = []
    
    let itemsPublisher: AnyPublisher<[ToggleItem], Never>
    let itemDidToggle: (ToggleItem, Bool) -> Void
    
    public init(
        itemsPublisher: AnyPublisher<[ToggleItem], Never>,
        itemDidToggle: @escaping (ToggleItem, Bool) -> Void
    ) {
        self.itemsPublisher = itemsPublisher
        self.itemDidToggle = itemDidToggle
    }
        
    var body: some View {
        List {
            Section(header: Text("Items")) {
                ForEach(items) { item in
                    Toggle(
                        item.name,
                        isOn: .init(
                            get: { item.isOn },
                            set: { itemDidToggle(item, $0) }
                        )
                    )
                }
            }
        }
        .animation(.default, value: items)
        .onReceive(itemsPublisher) { newItems in
            print("New items: \(newItems)")
            items = newItems
        }
    }
    
    struct ToggleItem: Swift.Identifiable, Equatable {
        let id: String
        let name: String
        let isOn: Bool

        public static func == (lhs: ToggleItem, rhs: ToggleItem) -> Bool {
            lhs.id == rhs.id && lhs.isOn == rhs.isOn
        }
    }
}


    
let itemsManager = ItemsManager(items: (1...10).map { .init(identifier: UUID().uuidString, description: "item \($0)") })

let publisher = itemsManager.itemsPublisher
    .map { myItems in
        myItems.map { myItem in
            MyView.ToggleItem(id: myItem.identifier, name: myItem.description, isOn: itemsManager.isItemEnabled(identifier: myItem.identifier))
        }
    }
    .eraseToAnyPublisher()

let view = MyView(itemsPublisher: publisher) { item, newValue in
    itemsManager.setEnabled(newValue, forIdentifier: item.id)
}