我在 SwiftUI 中找到了两种管理视图的方法，但我不知道有什么区别，也不知道哪种方法更好

Question

This class goes into all methods the same.

import SwiftUI

class NavModel: ObservableObject {
    @Published var fullDissmiss:Bool = true
}

first way

import SwiftUI

@main
struct trainingApp: App {
    
    var body: some Scene {
        WindowGroup {
            RootNavView()
        }
    }
}

import SwiftUI

struct RootNavView: View {
    
    @ObservedObject var navModel = NavModel()
    var body: some View {
        if(navModel.fullDissmiss == true){
            FirstRouteView(navModel: navModel)
        } else {
            SecondRouteView(navModel: navModel)
        }
    }
}

import SwiftUI

struct FirstRouteView: View {
    var navModel: NavModel
    var body: some View {
            VStack{
                Text("This First Route View")
                Button("Full dissmiss and second view show up"){
                    navModel.fullDissmiss = false
                }
        }
    }
}

import SwiftUI

struct SecondRouteView: View {
    var navModel: NavModel
    var body: some View {
            VStack{
                Text("This Second Route View")
                Button("Full dissmiss and first view show up"){
                    navModel.fullDissmiss = true
                }
        }
    }
}

second way

import SwiftUI

@main
struct trainingApp: App {
    
    var body: some Scene {
        WindowGroup {
            SGRootNavigationView(){}
        }
    }
}

import SwiftUI

struct SGRootNavigationView<Content>: View where Content: View {
    let cancellable = NotificationCenter.default.publisher(for: Notification.Name("SGGoToRoot"), object: nil)

    let content: () -> Content

    init(@ViewBuilder content: @escaping () -> Content) {
        print("SGRootNavigationView init()")
        self.content = content
    }

    @State var goToRoot:Bool = false

    var body: some View {
        return
            Group{
            if goToRoot == false{
                NavigationView {
                    FirstRouteView()
                }
            } else {
                NavigationView {
                    SecondRouteView()
                }
            }
            }.onReceive(cancellable, perform: {_ in
                DispatchQueue.main.async {
                    print("self.goToRoot : ", self.goToRoot)
                    self.goToRoot.toggle()
                    print("self.goToRoot : ", self.goToRoot)
                }
            })
    }
}

import SwiftUI

struct SGNavigationChildsView<Content>: View where Content: View {
    let notification = Notification(name: Notification.Name("SGGoToRoot"))
    
    var fullDissmiss:Bool{
        get{ return false }
        set{ if newValue {self.goToRoot()} }
    }
    
    let content: () -> Content
    
    init(fullDissmiss:Bool, @ViewBuilder content: @escaping () -> Content) {
        print("SGNavigationChildsView init")
        print("content : ", content)
        print("fullDissmiss : ", fullDissmiss)
        self.content = content
        self.fullDissmiss = fullDissmiss
    }
    
    var body: some View {
        content()
    }
    
    func goToRoot(){
        print("goToRoot : ", goToRoot)
        NotificationCenter.default.post(self.notification)
    }
}

import SwiftUI

struct FirstRouteView: View {
    @ObservedObject var navModel = NavModel()
    var body: some View {
        SGNavigationChildsView(fullDissmiss: self.navModel.fullDissmiss){
            VStack{
                Text("This First Route View")
                Button("Full dissmiss and second view show up"){
                    navModel.fullDissmiss = true
                }
            }
        }
    }
}

import SwiftUI

struct SecondRouteView: View {
    @ObservedObject var navModel = NavModel()
    var body: some View {
        SGNavigationChildsView(fullDissmiss: self.navModel.fullDissmiss){
            VStack{
                Text("This Second Route View")
                Button("Full dissmiss and first view show up"){
                    navModel.fullDissmiss = true
                }
            }
        }
    }
}

Is it difficult to see that the first method manages the root view?

The first method is easy, but I don't know if it can be managed simply like that.

I don't have enough knowledge to tell which one is the better way.

Is the second method better because FirstRouteView and SecondRouteView are managed in SGNavigationChildsView and those structures are managed in one structure (SGRootNavigationVIew)?

Answer 1

1. First method is for view presentation
2. Second method is for managing navigation controller stack

I'm using ObservableObject way but depending on your use case it might be a good idea to use the first method:

enum Page {
    case newAccount
    case existingAccount
}

@MainActor
class ViewRouter: ObservableObject {

    @Published var currentPage: Page = .newAccount
}

Notice that I am adding MainActor to make sure that I update views in main thread.

In main.swift:

@main
struct YOUR_APP_NAME: App {

    @StateObject nonisolated var viewRouter = ViewRouter()

    var body: some Scene {
        
        WindowGroup {

            MainView()
                .environmentObject(viewRouter)
        }
    }
}

Read more about nonisolated click here

struct MainView: View {

    @EnvironmentObject var viewRouter: ViewRouter

    var body: some View {

        switch viewRouter.currentPage {
        case .newAccount:
            // LoginView()
        case .existingAccount:
            // ContentView()
              // .transition(.scale) <-- Add animation when changing view
        }
    }
}