SwiftUI-ObservableObject重绘不相关的视图？

Question

When a @Published property is mutated in an ObservableObject , SwiftUI seems to re-draw views which do not depend on that property.

Example

You can see the behavior here:

// Our observed model
class Person: ObservableObject {
    @Published var name = "Bob"
    @Published var title = "Mr"
    static let shared = Person()
    init() {}
}


// Name view
struct NameView: View {
    @ObservedObject var person = Person.shared
    var body: some View {
        print("Redraw name")
        return TextField("Name", text: $person.name) // Binding to `name` only
    }
}

/* Elsewhere in the app... */
// Title view
struct TitleView: View {
    @ObservedObject var person = Person.shared
    var body: some View {
        print("Redraw title")
        return TextField("Title", text: $person.title) // Binding to `title` only
    }
}

Build an app containing both views, and change either the name OR the title. For each character typed, you'll see this console output:

Redraw name
Redraw title

Question

Why does TitleView 's body get re-computed when you modify name , and vice versa?

This has become a huge problem in my app: a shared User object (via @EnvironmentObject) is triggering drawing cycles in completely unrelated views. Modifying the User 's name in one view causes another view to re-render a long list of photos owned by the same User (expensive operation). What's worse - this happens with every keystroke typed .

Is SwiftUI smart enough to selectively redraw only views that display the mutated @Published property?

Answer 1

Under the hood @ObservedObject uses a Combine Subscriber to observe your ObservableObject .

Consider this refactor of your Person object:

class Person: ObservableObject {

    var name = "My name" {
        willSet { self.objectWillChange.send() }
    }
    var title = "My title" {
        willSet { self.objectWillChange.send() }
    }

    static let shared = Person()

    init() {}

}

As you can see the Person object "owns" a Publisher assigned to objectWillChange . And all @Property is doing is removing some boilerplate from your object model by handling willSet for you.

So ObservableObject itself is not granular enough to detect a change to a particular property in your model but rather is "broadcasting" a change for any property change in your model and @ObservedObject is simply subscribed to any change to your model.