@ObservedObject in iOS Swift - Deep Dive

Overview - @ObservedObject

What is it?

@ObservedObject is a property wrapper in SwiftUI that lets a view watch an external data source for changes. When the data changes, the view updates automatically to show the new information. It connects a view to a separate object that holds data and logic, keeping UI and data separate but in sync.

Why it matters

Without @ObservedObject, views would not update when data changes outside their own scope, causing the UI to show old or wrong information. This would make apps feel broken or unresponsive. @ObservedObject solves this by linking views to live data sources, so the app always shows the latest state without manual refreshes.

Where it fits

Before learning @ObservedObject, you should understand basic SwiftUI views and state management with @State. After this, you can learn about @StateObject for owning data, and @EnvironmentObject for sharing data across many views. This fits into the bigger topic of reactive UI programming in SwiftUI.

Mental Model

Core Idea

@ObservedObject lets a SwiftUI view watch an external data object and automatically refresh when that data changes.

Think of it like...

It's like having a friend who keeps you updated about their life. You don't control their actions, but whenever something important happens to them, they tell you so you can react accordingly.

View ── observes ──> Data Object
  │                          ▲
  │                          │
  └──── updates automatically ─┘

Build-Up - 7 Steps

1

Foundation

What is @ObservedObject in SwiftUI

Concept: Introducing @ObservedObject as a way for views to watch external data objects.

In SwiftUI, views can use @ObservedObject to connect to a class that conforms to ObservableObject. This class holds data and can notify views when data changes. The view then redraws itself to show the new data.

Result

The view updates automatically when the observed data changes.

Understanding that @ObservedObject links a view to an external data source is key to building dynamic interfaces.

2

Foundation

ObservableObject and @Published Basics

Concept: How ObservableObject and @Published work together to notify views.

A class marked ObservableObject can have properties marked with @Published. When these properties change, the class sends a signal. Views observing this class with @ObservedObject listen for these signals and update.

Result

Changing a @Published property triggers view updates automatically.

Knowing that @Published properties inside ObservableObject trigger updates helps you design reactive data models.

3

Intermediate

Using @ObservedObject in a SwiftUI View

🤔Before reading on: Do you think @ObservedObject creates or owns the data object, or just watches it? Commit to your answer.

Concept: @ObservedObject watches an existing data object but does not create or own it.

You declare a property in your view with @ObservedObject var model: YourModel. The model is created outside the view and passed in. The view listens to changes but does not manage the model's lifecycle.

Result

The view updates when model changes, but the model lives outside the view.

Understanding ownership clarifies when to use @ObservedObject versus @StateObject.

4

Intermediate

Difference Between @ObservedObject and @StateObject

🤔Before reading on: Which property wrapper do you think should be used when the view creates the data object? @ObservedObject or @StateObject? Commit to your answer.

Concept: @StateObject owns and creates the data object; @ObservedObject only watches an existing one.

@StateObject is used when the view creates and owns the data object, ensuring it stays alive. @ObservedObject is for watching objects created elsewhere. Using @ObservedObject to create an object can cause bugs because the object may be recreated unexpectedly.

Result

Choosing the right wrapper prevents data loss and unexpected behavior.

Knowing the ownership difference prevents common bugs with data lifecycle in SwiftUI.

5

Intermediate

Passing @ObservedObject Between Views

Concept: How to share an ObservableObject between multiple views using @ObservedObject.

You can create an ObservableObject in a parent view with @StateObject and pass it down to child views as @ObservedObject. This way, all views watch the same data source and update together.

Result

Multiple views stay in sync with shared data changes.

Sharing data with @ObservedObject enables coordinated UI updates across views.

6

Advanced

Avoiding Common @ObservedObject Pitfalls

🤔Before reading on: What happens if you use @ObservedObject to create a new data object inside a view? Commit to your answer.

Concept: Using @ObservedObject to create data causes the object to be recreated on every view update, losing state.

Because @ObservedObject expects an existing object, creating one inside the view means it resets every time the view redraws. This causes data loss and UI glitches. Instead, create the object outside or use @StateObject if the view owns it.

Result

Proper use prevents unexpected resets and keeps data stable.

Understanding lifecycle management is crucial to avoid subtle bugs with @ObservedObject.

7

Expert

How @ObservedObject Works with Combine Framework

🤔Before reading on: Do you think @ObservedObject uses notifications, delegates, or Combine publishers to detect changes? Commit to your answer.

Concept: @ObservedObject uses Combine publishers under the hood to listen for changes from ObservableObject.

ObservableObject protocol requires a publisher called objectWillChange. When @Published properties change, they send events through this publisher. @ObservedObject subscribes to this publisher and triggers view updates when it emits events.

Result

SwiftUI views react instantly to data changes via Combine's reactive streams.

Knowing the Combine integration reveals how SwiftUI achieves efficient, reactive UI updates.

Under the Hood

@ObservedObject subscribes to the ObservableObject's objectWillChange publisher from the Combine framework. When any @Published property changes, the ObservableObject emits an event. The subscription triggers SwiftUI to re-render the view. This subscription is managed automatically by SwiftUI, ensuring updates happen only when needed.

Why designed this way?

SwiftUI uses Combine to unify reactive programming and UI updates in a declarative way. This design allows views to stay simple and stateless, while data changes flow through a standard publisher-subscriber model. Alternatives like manual callbacks or notifications were more error-prone and less efficient.

┌───────────────┐       subscribes to       ┌─────────────────────┐
│ SwiftUI View  │ ─────────────────────────>│ ObservableObject     │
│ (@ObservedObj)│                           │ (with @Published)    │
└───────────────┘                           └─────────────────────┘
         │                                            ▲
         │                                            │
         └───────── triggers view update on event ───┘

Myth Busters - 4 Common Misconceptions

Quick: Does @ObservedObject create and own the data object it watches? Commit yes or no.

Common Belief: @ObservedObject creates and owns the data object inside the view.

Reality: @ObservedObject only watches an existing data object created elsewhere; it does not own or create it.

Why it matters: Misusing @ObservedObject to create data causes the object to be recreated on every view update, losing all stored data and causing UI glitches.

Quick: Does changing any property in an ObservableObject always update the view? Commit yes or no.

Common Belief: Any change in the ObservableObject triggers the view to update.

Reality: Only changes to properties marked with @Published send update signals; other changes do not trigger view refresh.

Why it matters: Not marking properties with @Published can cause the UI to not update, leading to stale or incorrect displays.

Quick: Can @ObservedObject be used to share data across many unrelated views easily? Commit yes or no.

Common Belief: @ObservedObject is the best way to share data across many views in an app.

Reality: @ObservedObject is for watching data passed directly to a view; @EnvironmentObject is better for sharing data widely across many views without manual passing.

Why it matters: Using @ObservedObject for wide data sharing leads to complex code and manual passing, increasing bugs and maintenance.

Quick: Does @ObservedObject always cause the entire view to redraw on any data change? Commit yes or no.

Common Belief: @ObservedObject causes the whole view to redraw on any change.

Reality: SwiftUI intelligently updates only the parts of the view that depend on the changed data, minimizing redraw cost.

Why it matters: Believing the whole view redraws can lead to unnecessary performance worries and premature optimization.

Expert Zone

1

Using @ObservedObject with classes that have complex internal state requires careful management to avoid inconsistent UI updates.

2

Combining @ObservedObject with other state wrappers like @State and @EnvironmentObject can cause subtle update order issues if not designed carefully.

3

The objectWillChange publisher can be customized to batch multiple changes into a single update, improving performance in complex models.

When NOT to use

@ObservedObject is not suitable when the view owns the data object; use @StateObject instead. For global app-wide data sharing, prefer @EnvironmentObject. For simple local state, use @State. Avoid @ObservedObject for immutable data or data that does not change.

Production Patterns

In production apps, @ObservedObject is often used to inject view models created by dependency injection frameworks. It enables MVVM architecture by separating UI from business logic. Developers also combine it with Combine operators to transform and debounce data streams before updating views.

Connections

Observer Pattern (Software Design)

Same pattern

Understanding @ObservedObject as a modern SwiftUI implementation of the observer pattern helps grasp how views react to data changes automatically.

Reactive Programming

Builds-on

Knowing reactive programming concepts clarifies how @ObservedObject uses Combine publishers to propagate changes efficiently.

Human Attention and Notifications

Analogy to real life

Just like people pay attention to notifications from friends or apps to stay updated, @ObservedObject lets views listen for data changes to stay current.

Common Pitfalls

#1 Creating the ObservableObject inside a view using @ObservedObject causes data loss.

Wrong approach:

struct MyView: View {
@ObservedObject var model = MyModel()
var body: some View { Text(model.text) }
}

Correct approach:

struct MyView: View {
@ObservedObject var model: MyModel
var body: some View { Text(model.text) }
}
// Create MyModel outside and pass it in

Root cause:

Misunderstanding that @ObservedObject does not own the data object and recreating it on every view update resets state.

#2 Not marking properties with @Published inside ObservableObject prevents view updates.

Wrong approach:

class MyModel: ObservableObject {
var text = "Hello"
}

Correct approach:

class MyModel: ObservableObject {
@Published var text = "Hello"
}

Root cause:

Forgetting that only @Published properties send change notifications to views.

#3 Passing ObservableObject to many views without @EnvironmentObject leads to complex code.

Wrong approach:

Passing the same ObservableObject manually through many view initializers using @ObservedObject.

Correct approach:

Use @StateObject in a parent and @EnvironmentObject in child views for easier data sharing.

Root cause:

Not using the right property wrapper for wide data sharing increases boilerplate and error risk.

Key Takeaways

@ObservedObject connects a SwiftUI view to an external data object that can change over time.

It listens to changes from ObservableObject classes that use @Published properties to notify updates.

@ObservedObject does not create or own the data; it only watches it, so ownership matters.

Using @ObservedObject incorrectly can cause data loss or stale UI, so understanding lifecycle is crucial.

Under the hood, @ObservedObject uses Combine publishers to efficiently update views reactively.