SwiftUI 内存泄漏

Question

在使用List 和id: \.self 时，我在SwiftUI 中遇到了奇怪的内存泄漏，其中只有一些项目被破坏。我正在使用 macOS Monterey Beta 5。

复制方法如下：

1. 新建一个空白的 SwiftUI macOS 项目
2. 粘贴以下代码：

class Model: ObservableObject {
    @Published var objs = (1..<100).map { TestObj(text: "\($0)")}
}
class TestObj: Hashable {
    let text: String
    static var numDestroyed = 0
    
    init(text: String) {
        self.text = text
    }
    static func == (lhs: TestObj, rhs: TestObj) -> Bool {
        return lhs.text == rhs.text
    }
    func hash(into hasher: inout Hasher) {
        hasher.combine(text)
    }
    
    deinit {
        TestObj.numDestroyed += 1
        print("Deinit: \(TestObj.numDestroyed)")
    }
}
struct ContentView: View {
    @StateObject var model = Model()
    
    var body: some View {
        NavigationView {
            List(model.objs, id: \.self) { obj in
                Text(obj.text)
            }
            Button(action: {
                var i = 1
                model.objs.removeAll(where: { _ in
                    i += 1
                    return i % 2 == 0
                })
            }) {
                Text("Remove half")
            }
        }
    }
}

1. 运行应用程序，然后按“删除一半”按钮。一直按住它，直到所有物品都消失。但是，如果您查看控制台，您会看到只有 85 件物品被销毁，而有 99 件物品。 Xcode 内存图也支持这一点。

这似乎是由id: \.self 行引起的。删除它并将其切换为 id: \.text 可以解决问题。

但是我使用id: \.self 的原因是因为我想支持多选，并且我希望选择的类型是Set<TestObj>，而不是Set<UUID>。

有没有办法解决这个问题？

Answer 1

如果您不必在 List 中使用选择，则可以使用任何唯一且常量 id，例如：

class TestObj: Hashable, Identifiable {
    let id = UUID()

    /* ... */
}

然后你的List 带有隐含的id: \.id：

List(model.objs) { obj in
    Text(obj.text)
}

这很好用。它之所以有效，是因为现在您不再通过 SwiftUI 保留的引用类型来识别列表中的行。相反，您使用的是值类型，因此没有任何强引用导致 TestObjs 无法释放。

但是您需要在List 中进行选择，因此请参阅下文了解如何实现。

---

为了让这个与选择一起工作，我将使用来自Swift Collections 的OrderedDictionary。这样列表行仍然可以像上面一样用id 标识，但我们可以快速访问它们。它部分是字典，部分是数组，因此通过键访问元素需要 O(1) 时间。

首先，这里是从数组创建这个字典的扩展，所以我们可以通过它的id来识别它：

extension OrderedDictionary {
    /// Create an ordered dictionary from the given sequence, with the key of each pair specified by the key-path.
    /// - Parameters:
    ///   - values: Every element to create the dictionary with.
    ///   - keyPath: Key-path for key.
    init<Values: Sequence>(_ values: Values, key keyPath: KeyPath<Value, Key>) where Values.Element == Value {
        self.init()
        for value in values {
            self[value[keyPath: keyPath]] = value
        }
    }
}

将您的 Model 对象更改为：

class Model: ObservableObject {
    @Published var objs: OrderedDictionary<UUID, TestObj>

    init() {
        let values = (1..<100).map { TestObj(text: "\($0)")}
        objs = OrderedDictionary<UUID, TestObj>(values, key: \.id)
    }
}

您将使用model.objs.values 而不是model.objs，仅此而已！

查看下面的完整演示代码以测试选择：

struct ContentView: View {
    @StateObject private var model = Model()
    @State private var selection: Set<UUID> = []

    var body: some View {
        NavigationView {
            VStack {
                List(model.objs.values, selection: $selection) { obj in
                    Text(obj.text)
                }

                Button(action: {
                    var i = 1
                    model.objs.removeAll(where: { _ in
                        i += 1
                        return i % 2 == 0
                    })
                }) {
                    Text("Remove half")
                }
            }
            .onChange(of: selection) { newSelection in
                let texts = newSelection.compactMap { selection in
                    model.objs[selection]?.text
                }

                print(texts)
            }
            .toolbar {
                ToolbarItem(placement: .primaryAction) {
                    EditButton()
                }
            }
        }
    }
}

结果：