Resolving SwiftUI View Updates with Custom Object Property Changes

Learn how to efficiently handle view updates in SwiftUI when custom objects undergo property changes. This guide explains the importance of Equatable conformance and Identifiable protocol for dynamic UI updates.
---

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 update a view with custom object property change

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Resolving SwiftUI View Updates with Custom Object Property Changes

SwiftUI is a powerful UI toolkit that allows developers to build dynamic interfaces for their applications in a declarative manner. However, while converting your applications to SwiftUI, you may encounter some common issues related to state management and view updates. One such problem arises when a custom object’s properties change, but the corresponding views do not update as expected. In this guide, we will explore this problem, focusing on how to properly leverage SwiftUI’s Equatable conformance and Identifiable protocol to resolve such issues efficiently.

The Problem

While working with SwiftUI, you may have noticed that the UI does not always refresh automatically when properties in your custom objects change. For example, you are using Parse live queries to maintain an array of custom objects representing candidates. When you update a candidate’s property, the UI might fail to reflect that change, despite the data in your ViewModel being updated correctly.

The root cause of this issue is typically associated with how SwiftUI uses equality checking to determine if a view needs to be updated. If SwiftUI doesn’t deem an object as “changed,” the associated view will not refresh. Let’s take a closer look at the code that typically demonstrates this issue.

An Example Implementation

Here’s a simplified version of a candidate model structured for use in SwiftUI:

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

The Equatable conformance is currently only checking the objectId. Hence, if any other property, like name or status, changes, it will not trigger an update in SwiftUI.

The Solution

To ensure that updates are reflected in the UI when any property of a custom object changes, we need to make a couple of significant adjustments to our model.

Step 1: Make Your Model Identifiable

First, we should make the Candidate structure conform to the Identifiable protocol, which helps SwiftUI uniquely identify items in a list.

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

By adding Identifiable, we ensure that SwiftUI can differentiate between each instance of the Candidate model.

Step 2: Modify the Equatable Conformance

Next, we should rethink how we define equality. Instead of just considering the objectId, we should likely compare all properties that may influence the state.

Here’s an updated implementation:

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

This way, SwiftUI can detect changes effectively whenever any relevant property is modified.

Step 3: Update the ViewModel

In the CandidatesViewModel, when the updateCandidate method is called, make sure we adjust how we find our candidate within the list based on the objectId:

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

This ensures that the correct instance in the candidatesList gets updated.

Step 4: Update the View Code

Now, when setting up your view, ensure you are using the updated ForEach calls with the Identifiable protocol:

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

By not using id: .self, SwiftUI can now take full advantage of the Identifiable compliance for better performance and correctness when refreshing views.

Conclusion

By properly implementing both the Equatable and Identifiable protocols in your custom objects, you can overcome the issue of stale UI updates in SwiftUI. This approach ensures that any change to a candidate’s properties is immediately reflected in your user interface, allowing for a smooth and seamless user experience.

If you face similar problems with SwiftUI updates in your applications, remember to check your model’s equal