Do I have to use an ObservableObject in SwiftUI?

Question

I would like to use a struct instead of a class as a state for my View, and as you may know, ObservableObject is a protocol only classes can conform to.

Do I have to wrap my struct in a ViewModel or some other similar type of object ? What happens if I don't ?

A sample on what that looks like now :

import Foundation
import SwiftUI

struct Object3D {
    var x : Int
    var y : Int
    var z : Int
    var visible : Bool
}

struct NumberView<Number : Strideable> : View {
    var label : String
    @State var number : Number
    
    var body : some View {
        HStack {
            TextField(
                self.label,
                value: self.$number,
                formatter: NumberFormatter()
            )
            Stepper("", value: self.$number)
                .labelsHidden()
        }
    }
}

struct ObjectInspector : View {
    @State var object : Object3D
    
    var body : some View {
        VStack {
            Form {
                Toggle("Visible", isOn: $object.visible)
            }
            Divider()
            Form {
                HStack {
                    NumberView(label: "X:", number: object.x)
                    NumberView(label: "Y:", number: object.y)
                    NumberView(label: "Z:", number: object.z)
                }
            }
        }
        .padding()
    }
}

struct ObjectInspector_Previews: PreviewProvider {
    static var previews: some View {
        ObjectInspector(object: Object3D(x: 0, y: 0, z: 0, visible: true))
    }
}

score 3 · Accepted Answer · answered Jun 22 '22 at 14:10

You don't have to use @ObservedObject to ensure that updates to your model object are updating your view.

If you want to use a struct as your model object, you can use @State and your view will be updated correctly whenever your @State struct is updated.

There are lots of different property wrappers that you can use to update your SwiftUI views whenever your model object is updated. You can use both value and reference types as your model objects, however, depending on your choice, you have to use different property wrappers.

@State can only be used on value types and @State properties can only be updated from inside the view itself (hence they must be private).

@ObservedObject (and all other ...Object property wrappers, such as @EnvironmentObject and @StateObject) can only be used with classes that conform to ObservableObject. If you want to be able to update your model objects from both inside and outside your view, you must use an ObservableObject conformant type with the appropriate property wrapper, you cannot use @State in this case.

So think about what sources your model objects can be updated from (only from user input captured directly inside your View or from outside the view as well - such as from other views or from the network), whether you need value or reference semantics and make the appropriate choice for your data model accordingly.

For more information on the differences between @ObservedObject and @StateObject, see What is the difference between ObservedObject and StateObject in SwiftUI.

Thank you. The fact that @State can only be updated from inside the view might be a problem here, so I think I’m going to use objects instead of structs. — ice-wind, Jun 22 '22 at 14:36

Caleb · Answer 2 · 2022-06-23T00:25:08.000

I would like to use a struct instead of a class as a state for my View, and as you may know, ObservableObject is a protocol only classes can conform to.

A model is usually shared among whichever parts of the app need it, so that they're all looking at the same data all the time. For that, you want a reference type (i.e. a class), so that everybody shares a single instance of the model. If you use a value type (i.e. a struct), your model will be copied each time you assign it to something. To make that work, you'd need to copy the updated info back to wherever it belongs whenever you finish updating it, and then arrange for every other part of the app that might use it to get an updated copy. It's usually a whole lot easier and safer to share one instance than to manage that sort of updating.

Do I have to wrap my struct in a ViewModel or some other similar type of object ? What happens if I don't ?

It's your code -- you can do whatever you like. ObservableObject provides a nice mechanism for communicating the fact that your model has changed to other parts of your program. It's not the only possible way to do that, but it's the way that SwiftUI does it, so if you go another route you're going to lose out on a lot of support that's built into SwiftUI.

Wait I thought `classes` were reference type and `structs` were value type ? Don't Structs have copy-on-write ? — ice-wind, Jun 22 '22 at 19:25
Yeah I think you got it reversed though the explanation still holds : https://developer.apple.com/swift/blog/?id=10 — ice-wind, Jun 22 '22 at 19:26
@Crysambrosia Right, sorry about that, totally backwards. Will fix. Thanks. — Caleb, Jun 23 '22 at 00:24
@Crysambrosia custom structs don't implement copy-on-write by default. Most standard library collections, such as `Array` and `Dictionary` do support copy-on-write, but if you create a custom `struct`, you need to manually add copy-on-write support to it. — Dávid Pásztor, Jun 23 '22 at 08:17

score 0 · Answer 3 · answered Jun 23 '22 at 17:36

The View is a struct already, it cannot be a class. It holds the data that SwiftUI diffs to update the actual UIViews and NSViews on screen. It uses the @State and @Binding property wrappers to make it behave like a class, i.e. so when the hierarchy of View structs is recreated they are given back their property values from last time. You can refactor groups of vars into their own testable struct and include mutating funcs.

You usually only need an ObservableObject if you are using Combine, it's part of the Combine framework.

I recommend watching Data Flow through SwiftUI WWDC 2019 for more detail.

Do I have to use an ObservableObject in SwiftUI?

3 Answers3