Do I Need to Avoid Custom View Inits When Using a StateObject Which Relies on Passed Information?

If you’re a SwiftUI developer, you’ve likely run into the scenario where you need to pass information to a view and then initialize a StateObject with that information. But, you might be wondering: do I need to avoid custom view inits when using a StateObject which relies on passed information?

The Short Answer: Yes (Mostly)

In most cases, yes, you should avoid custom view inits when using a StateObject that relies on passed information. But, before we dive deeper, let’s take a step back and understand why.

What is a StateObject?

A StateObject is a reference type that you use to store and manage the state of an app in SwiftUI. It’s essentially a way to create a shared instance of a class that can be accessed and updated from multiple views.

@main
struct MyApp: App {
    @StateObject var settings = Settings()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(settings)
        }
    }
}

What is a Custom View Init?

A custom view init, or initializer, is a way to create a custom initialization process for a view. It’s a function that is called when a view is created, and it can be used to set up the view’s properties and state.

struct MyView: View {
    let name: String

    init(name: String) {
        self.name = name
    }

    var body: some View {
        Text("Hello, \(name)!")
    }
}

The Problem with Custom View Inits and StateObjects

When you use a custom view init and a StateObject together, things can get tricky. The problem arises when the StateObject relies on passed information, such as an ID or a string, to initialize itself.

Let’s say you have a view that takes an ID as a parameter, and you want to use that ID to initialize a StateObject:

struct MyView: View {
    let id: Int

    init(id: Int) {
        self.id = id
        _settings = StateObject(wrappedValue: Settings(id: id))
    }

    @StateObject var settings: Settings

    var body: some View {
        Text("Hello, \(settings.name)!")
    }
}

This code might look innocent, but it has a big problem: the StateObject is being initialized in the view’s init method. This means that every time the view is recreated, the StateObject will be reinitialized with the new ID.

But, what if you want to keep the StateObject’s state across view recreations? This is where things get tricky.

The Solution: Avoid Custom View Inits

The solution is simple: avoid custom view inits when using a StateObject that relies on passed information. Instead, use a standard initializer and let SwiftUI manage the StateObject’s initialization.

struct MyView: View {
    let id: Int
    @StateObject var settings: Settings

    init(id: Int) {
        self.id = id
    }

    var body: some View {
        if let settings = settings {
            Text("Hello, \(settings.name)!")
        } else {
            Text("Loading...")
        }
    }
}

struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            MyView(id: 1)
                .environmentObject(Settings(id: 1))
        }
    }
}

In this example, we’ve moved the StateObject initialization to the MyApp struct, where it’s properly managed by SwiftUI. Now, the StateObject’s state will be preserved across view recreations.

But What About Performance?

One possible concern with this approach is performance. If you’re initializing the StateObject in the MyApp struct, doesn’t that mean it will be created every time the app is launched?

The answer is: not necessarily. SwiftUI has a built-in optimization that prevents StateObjects from being recreated unnecessarily. This means that, even if you initialize the StateObject in the MyApp struct, it will only be created once and then reused across the app.

Conclusion

In conclusion, when using a StateObject that relies on passed information, it’s generally best to avoid custom view inits. Instead, use a standard initializer and let SwiftUI manage the StateObject’s initialization. This will ensure that the StateObject’s state is preserved across view recreations and that performance is optimized.

Frequently Asked Questions

Here are some frequently asked questions about using StateObjects with custom view inits:

Q: Can I use a custom view init with a StateObject if I’m not passing any information?

A: Yes, if you’re not passing any information to the StateObject, it’s okay to use a custom view init. However, keep in mind that the StateObject will still be recreated every time the view is recreated.

Q: What if I need to perform some complex initialization logic for my StateObject?

A: In this case, you can use a combination of a custom view init and a lazy property wrapper to perform the initialization logic. However, be careful not to recreate the StateObject unnecessarily, as this can lead to performance issues.

Q: Can I use a StateObject with a custom view init in a UIKit app?

A: No, StateObjects are a SwiftUI-specific feature and can only be used in SwiftUI apps.

Scenario	Use Custom View Init?	Why?
StateObject with no passed information	Yes	The StateObject won’t be recreated unnecessarily.
StateObject with passed information	No	The StateObject’s state might be lost across view recreations.
Complex initialization logic	Might be okay	Use with caution and consider performance implications.
UIKit app	No	StateObjects are SwiftUI-specific.

By following these guidelines, you can ensure that your StateObjects are properly initialized and managed, and that your SwiftUI app is efficient and scalable.

Final Thoughts

In conclusion, when working with StateObjects and passed information, it’s generally best to avoid custom view inits and let SwiftUI manage the initialization process. This will ensure that your app’s state is preserved across view recreations and that performance is optimized.

Remember, SwiftUI is a powerful and flexible framework, and by following best practices and guidelines, you can build robust and efficient apps that delight your users.

Frequently Asked Question

When it comes to using a state object that relies on passed information, do I need to avoid custom view inits? Let’s dive into the details!