Thursday, February 15, 2024
HomeIOS DevelopmentUnderstanding SwiftUI view lifecycles – Ole Begemann

Understanding SwiftUI view lifecycles – Ole Begemann

I wrote an app referred to as SwiftUI View Lifecycle. The app means that you can observe how completely different SwiftUI constructs and containers have an effect on a view’s lifecycle, together with the lifetime of its state and when onAppear will get referred to as. The code for the app is on GitHub. It may be constructed for iOS and macOS.

Once we write SwiftUI code, we assemble a view tree that consists of nested view values. Cases of the view tree are ephemeral: SwiftUI always destroys and recreates (components of) the view tree because it processes state adjustments.

The view tree serves as a blueprint from which SwiftUI creates a second tree, which represents the precise view “objects” which can be “on display screen” at any given time (the “objects” may very well be precise UIView or NSView objects, but additionally different representations; the precise which means of “on display screen” can fluctuate relying on context). Chris Eidhof likes to name this second tree the render tree (the hyperlink factors to a 3 minute video the place Chris demonstrates this duality, extremely advisable).

The render tree persists throughout state adjustments and is utilized by SwiftUI to ascertain view id. When a state change causes a change in a view’s worth, SwiftUI will discover the corresponding view object within the render tree and replace it in place, relatively than recreating a brand new view object from scratch. That is after all key to creating SwiftUI environment friendly, however the render tree has one other necessary perform: it controls the lifetimes of views and their state.

We are able to outline a view’s lifetime because the timespan it exists within the render tree. The lifetime begins with the insertion into the render tree and ends with the elimination. Importantly, the lifetime extends to view state outlined with @State and @StateObject: when a view will get faraway from the render tree, its state is misplaced; when the view will get inserted once more later, the state shall be recreated with its preliminary worth.

The SwiftUI View Lifecycle app tracks three lifecycle occasions for a view and shows them as timestamps:

  • @State = when the view’s state was created (equal to the beginning of the view’s lifetime)
  • onAppear = when onAppear was final referred to as
  • onDisappear = when onDisappear was final referred to as

A table with three rows. @State: 1:26 ago. onAppear: 0:15 ago. onDisappear: 0:47 ago.
The lifecycle monitor view shows the timestamps when sure lifecycle occasions final occurred.

The app means that you can observe these occasions in several contexts. As you click on your manner via the examples, you’ll discover that the timing of those occasions adjustments relying on the context a view is embedded in. For instance:

  • An if/else assertion creates and destroys its baby views each time the situation adjustments; state is just not preserved.
  • A ScrollView eagerly inserts all of its kids into the render tree, no matter whether or not they’re contained in the viewport or not. All kids seem instantly and by no means disappear.
  • A Listing with dynamic content material (utilizing ForEach) lazily inserts solely the kid views which can be presently seen. However as soon as a baby view’s lifetime has began, the listing will preserve its state alive even when it will get scrolled offscreen once more. onAppear and onDisappear get referred to as repeatedly as views are scrolled into and out of the viewport.
  • A NavigationStack calls onAppear and onDisappear as views are pushed and popped. State for dad or mum ranges within the stack is preserved when a baby view is pushed.
  • A TabView begins the lifetime of all baby views instantly, even the non-visible tabs. onAppear and onDisappear get referred to as repeatedly because the person switches tabs, however the tab view retains the state alive for all tabs.

Listed here are a number of classes to remove from this:

  • Completely different container views could have completely different efficiency and reminiscence utilization behaviors, relying on how lengthy they preserve baby views alive.
  • onAppear isn’t essentially referred to as when the state is created. It could occur later (however by no means earlier).
  • onAppear may be referred to as a number of instances in some container views. When you want a aspect impact to occur precisely as soon as in a view’s lifetime, contemplate writing your self an onFirstAppear helper, as proven by Ian Eager and Jordan Morgan in Operating Code Solely As soon as in SwiftUI (2022-11-01).

I’m certain you’ll discover extra fascinating tidbits while you play with the app. Suggestions is welcome!



Please enter your comment!
Please enter your name here

Most Popular

Recent Comments