#ObservedObject model lifecycle? - swiftui

Question

I'm testing #ObservedObject to test how SwiftUI handles the lifecycle of the model.
As I understand things now, from WWDC videos and documentation, is that the View that creates the model object (a class adopting ObservableObject) should use #StateObject.
From WWDC videos they clearly state that #ObservedObject does not own the observed instance lifecycle.
So I created this simple setup:
struct TestParentView: View {
#ObservedObject var model:TestModel
var body: some View {
VStack {
Text("TEST TEXT. \(model.name)")
TestChildView(model: model)
}
}
}
struct TestParentView_Previews: PreviewProvider {
static var previews: some View {
TestParentView(model: TestModel())
}
}
struct TestChildView: View {
#ObservedObject var model:TestModel
var body: some View {
Button(action: {
print("change name")
model.changeName()
}, label: {
Text("Change Name")
})
}
}
struct TestChildView_Previews: PreviewProvider {
static var previews: some View {
TestChildView(model: TestModel())
}
}
The model I used here is this:
class TestModel:ObservableObject {
#Published var name:String = ""
let id = UUID()
func changeName() {
name = "\(UUID())"
}
deinit {
print("TestModel DEINIT. \(id)")
}
}
When I run this app, I was expecting the TestModel instance created in TestParentView to be de-initialized at least at some point since #ObservedObject does not own the lifecycle of the model.
When I tap on the button to trigger a name change all works, but the TestModel DEINIT never gets called.
From all of this, it looks like TestParentView has a strong reference to the TestModel and it never lets it go.
So, what do they mean then when they say that #ObservedObject does not manage the lifecycle of model in this case?
Why is the TestModel DEINIT never called if #ObservedObject does not manage the model's lifecycle?
I'm obviously missing something here.

Answer 1

Assume this View:
struct Foo: View {
#ObservedObject var model = TestModel()
var body: some View {
Text(model.name)
}
}
Every time this view is created, it instantiates a new instance of TestModel.
SwiftUI views are really more like view descriptions which are created and destroyed a lot during your app lifecycle. Therefore it's important that the structs are lightweight. The Foo view isn't very lightweight because every rendering pass it instantiates a new model.
If you instead used #StateObject, the framework will only instantiate a TestModel the first time. After that it will reuse that same instance. This makes it way more performant.
Rule of thumb:
If the view creates its own model (such as the Foo view), use #StateObject.
If the model is passed in from the outside, use #ObservedObject.
To answer your question: "Why is the TestModel DEINIT never called".
You state that: "When I run this app, I was expecting the TestModel instance created in TestParentView to be de-initialized at least at some point".
The subtle detail is that the TestModel is not created in the TestParentView, it's merely passed in.
It is created in the TestParentView_Previews. And since the body of the TestParentView_Previews is only executed once, the TestModel will also only be initialised once, and thus never deallocated.