Updated for Xcode 12.0
SwiftUI gives us the @ObservedObject
property wrapper so that views can watch the state of an external object, and be notified when something important has changed.
For example, we might use something like this:
class Order: ObservableObject {
@Published var items = [String]()
}
struct ContentView: View {
@ObservedObject var order = Order()
var body: some View {
// your code here
}
}
That Order
class uses @Published
so it will automatically send change announcements when items
changes, and ContentView
uses @ObservedObject
to watch for those announcements. Without @ObservedObject
the change announcements would be sent but ignored.
Although that looks straightforward enough, it’s worth digging into a few specifics.
First, any type you mark with @ObservedObject
must conform to the ObservableObject
protocol, which in turn means it must be a class rather than a struct. This isn’t optional – SwiftUI requires us to use a class here.
Second, observed objects are specifically designed for data that is external to your view, which means it might be shared across more than one view. The @ObservedObject
property wrapper will automatically make sure the property is watched closely so that important changes will reload any views using it.
Third, not all properties in an observed object cause views to refresh – you need to decide which properties should send change notifications, either using @Published
or custom announcements. Types that conform to ObservableObject
are given a default objectWillChange
publisher to make custom announcements as needed.
SPONSORED Would you describe yourself as knowledgeable, but struggling when you have to come up with your own code? Fernando Olivares has a new book containing iOS rules you can immediately apply to your coding habits to see dramatic improvements, while also teaching applied programming fundamentals seen in refactored code from published apps.
Sponsor Hacking with Swift and reach the world's largest Swift community!
Link copied to your pasteboard.