Скачать или смотреть How to Keep Your ObservableObject State in SwiftUI When Redrawn

Discover why `@ State` persists its value across redraws while `@ ObservedObject` does not, and learn how to transition to `@ StateObject` for effective state management in SwiftUI
---
This video is based on the question https://stackoverflow.com/q/61676823/ asked by the user 'KonDeichmann' ( https://stackoverflow.com/u/4101776/ ) and on the answer https://stackoverflow.com/a/62524506/ provided by the user 'KonDeichmann' ( https://stackoverflow.com/u/4101776/ ) 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: ObservableObject does not persist its State over being redrawn

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.
---
How to Keep Your ObservableObject State in SwiftUI When Redrawn

SwiftUI has rapidly emerged as a powerful framework for building user interfaces on Apple platforms. One of the appealing features of SwiftUI is its declarative nature, which keeps the code clean and focused. However, developers occasionally encounter issues, particularly concerning the state management of ObservableObject. This guide addresses a common problem: why ObservableObject does not persist its state when its parent view gets redrawn and offers a solution.

Understanding the Problem

In SwiftUI, developers often create ViewModels for each view to separate business logic from the view itself. Unfortunately, when the parent view's state changes and triggers a redraw, the ObservableObject associated with the child view can get recreated as well, losing its previous state. This behavior can be frustrating, especially when you compare it to other frameworks, like Flutter, where the state persists during redraws.

Example of ObservableObject

Here's a simple implementation of an ObservableObject in SwiftUI:

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

This design works correctly until the parent view gets redrawn — at which point, the ViewModel resets itself, losing any previous state. Many developers, including myself, feel that the ViewModel should persist its state throughout the lifecycle of the view.

The Challenge of State Management

You might find workarounds like using @ State instead of @ ObservedObject to manage simpler states. Doing so allows the value to persist across redraws:

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

However, this approach can quickly become unwieldy for more complex states. If you try to set a class for @ State, you may discover that it doesn't behave as expected or that it's too simplistic for the task at hand.

Introducing the Solution: @ StateObject

Fortunately, Apple has provided a solution to this issue. Starting in iOS 14, you can utilize the @ StateObject property wrapper instead of @ ObservedObject. This is how you can implement it:

Implementation of @ StateObject

Here’s an example demonstrating the difference between @ ObservedObject and @ StateObject:

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

Observations from the Example

In this example, TestView1 uses @ ObservedObject, meaning that its state resets every time the parent (ContentView) redraws. On the other hand, TestView2 uses @ StateObject, allowing it to maintain its value across redraws, eliminating the frustration of losing state.

Conclusion

SwiftUI’s @ StateObject offers a robust solution for managing the state of your ObservableObject. It permits you to keep the state intact during view redraws while maintaining the benefits of a clean, declarative architecture. While the transition to @ StateObject requires iOS 14 or later, this update significantly enhances SwiftUI's capabilities for complex applications, providing a valuable tool for developers looking to create seamless, stateful user experiences.

With this new understanding, you can build more responsive and user-friendly applications without the hindrance of losing valuable state data each time your view redraws. Happy coding!