Resolving SwiftUI Binding Issues with @ObservedObject and @Published

Описание: Learn how to effectively observe changes in a nested `-Published` object within SwiftUI, ensuring your view updates correctly.
---
This video is based on the question https://stackoverflow.com/q/70128744/ asked by the user 'Shawn' ( https://stackoverflow.com/u/174507/ ) and on the answer https://stackoverflow.com/a/70129071/ provided by the user 'George' ( https://stackoverflow.com/u/9607863/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: SwiftUI observe published object of published object

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding SwiftUI's -ObservedObject and -Published Bindings

When working with SwiftUI, we often face issues related to observing changes in our data models. A common scenario arises when we need to observe a -Published property of another -Published object—especially when adding functionality like adding players in a game setup. This post will break down the problem and provide a solution to ensure your view updates as expected every time a player is added.

The Problem: Non-Updating View

In the code provided, we encounter a situation where pressing a button to add a player does not update the counter displayed in the UI. The primary reason is that while the game object's players array is being mutated, the reference to the game object itself is not changing. This leads to the following issues:

The ContentViewModel does not register any changes to game because only the content inside it is being modified, not the object reference.

Consequently, the didSet observer for game in ContentViewModel is never triggered, preventing the subscription to objectWillChange from being set.

The Solution: Setting up Observations Properly

To fix the problem, we need to ensure that the subscription to changes in the game object is established correctly. Here's a step-by-step breakdown of how to modify the ContentViewModel to achieve this:

Step 1: Change the ContentViewModel Class

We will adjust the ContentViewModel class as follows:

Remove the didSet method for game where the subscription is set.

Directly initialize the subscription in the init method.

Here’s the revised code snippet:

[[See Video to Reveal this Text or Code Snippet]]

Step 2: How the Subscription Works

By placing the subscription inside the init function:

Immediate Observation: The init method will be called every time a new instance of ContentViewModel is created, and thus our subscription will set up from the start.

Reactive Updates: Now, whenever players inside game changes, objectWillChange will emit a signal, making ContentViewModel aware of the change and pushing the updates to the view.

Step 3: Testing the Fix

Now, let's ensure that our ContentView correctly displays the number of players in the game. With the changes in place, pressing the "Add player" button should now successfully update the counter on the UI.

Here’s what the ContentView looks like:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

By understanding how SwiftUI manages object references and observations, you can effectively troubleshoot and fix binding issues. Properly setting up your subscriptions ensures that your views respond correctly to data changes, enhancing the overall reactivity of your SwiftUI application. Always remember that it’s not just about altering the object’s content but also about maintaining the connections that inform your views of these changes.

With these adjustments, your SwiftUI experience will become smoother, allowing for dynamic updates in your application. Happy coding!