SwiftUI NavigationLink 立即加载目标视图，无需单击

Question

使用以下代码：

struct HomeView: View {
    var body: some View {
        NavigationView {
            List(dataTypes) { dataType in
                NavigationLink(destination: AnotherView()) {
                    HomeViewRow(dataType: dataType)
                }
            }
        }
    }
}

奇怪的是，当HomeView 出现时，NavigationLink 立即加载AnotherView。结果，所有AnotherView 依赖项也被加载，即使它在屏幕上还不可见。用户必须单击该行以使其显示。 我的AnotherView 包含一个DataSource，发生各种事情。问题是此时整个 DataSource 已加载，包括一些计时器等。

我做错了什么..？如何以这种方式处理它，一旦用户按下 AnotherView 就会加载 HomeViewRow？

Answer 1

适用于 iOS 14 SwiftUI。

基于 post 的延迟导航目的地加载的非优雅解决方案，使用视图修饰符。

extension View {
    func navigate<Value, Destination: View>(
        item: Binding<Value?>,
        @ViewBuilder content: @escaping (Value) -> Destination
    ) -> some View {
        return self.modifier(Navigator(item: item, content: content))
    }
}

private struct Navigator<Value, Destination: View>: ViewModifier {
    let item: Binding<Value?>
    let content: (Value) -> Destination
    
    public func body(content: Content) -> some View {
        content
            .background(
                NavigationLink(
                    destination: { () -> AnyView in
                        if let value = self.item.wrappedValue {
                            return AnyView(self.content(value))
                        } else {
                            return AnyView(EmptyView())
                        }
                    }(),
                    isActive: Binding<Bool>(
                        get: { self.item.wrappedValue != nil },
                        set: { newValue in
                            if newValue == false {
                                self.item.wrappedValue = nil
                            }
                        }
                    ),
                    label: EmptyView.init
                )
            )
    }
}

这样称呼它：

struct ExampleView: View {
    @State
    private var date: Date? = nil
    
    var body: some View {
        VStack {
            Text("Source view")
            Button("Send", action: {
                self.date = Date()
            })
        }
        .navigate(
            item: self.$date,
            content: {
                VStack {
                    Text("Destination view")
                    Text($0.debugDescription)
                }
            }
        )
    }
}

Answer 2

在目标视图中，您应该监听事件onAppear 并在那里放置仅在新屏幕出现时才需要执行的所有代码。像这样：

struct DestinationView: View {
    var body: some View {
        Text("Hello world!")
        .onAppear {
            // Do something important here, like fetching data from REST API
            // This code will only be executed when the view appears
        }
    }
}

Answer 3

编辑：请参阅@MwcsMac 的答案以获得更简洁的解决方案，该解决方案将视图创建包装在闭包中，并且仅在视图呈现后才对其进行初始化。

它需要一个自定义的ForEach 来执行您的要求，因为函数构建器确实必须评估表达式

NavigationLink(destination: AnotherView()) {
    HomeViewRow(dataType: dataType)
}

每个可见行都能够显示HomeViewRow(dataType:)，在这种情况下AnotherView()也必须初始化。

因此，为避免这种情况，需要自定义 ForEach。

import SwiftUI

struct LoadLaterView: View {
    var body: some View {
        HomeView()
    }
}

struct DataType: Identifiable {
    let id = UUID()
    var i: Int
}

struct ForEachLazyNavigationLink<Data: RandomAccessCollection, Content: View, Destination: View>: View where Data.Element: Identifiable {
    var data: Data
    var destination: (Data.Element) -> (Destination)
    var content: (Data.Element) -> (Content)
    
    @State var selected: Data.Element? = nil
    @State var active: Bool = false
    
    var body: some View {
        VStack{
            NavigationLink(destination: {
                VStack{
                    if self.selected != nil {
                        self.destination(self.selected!)
                    } else {
                        EmptyView()
                    }
                }
            }(), isActive: $active){
                Text("Hidden navigation link")
                    .background(Color.orange)
                    .hidden()
            }
            List{
                ForEach(data) { (element: Data.Element) in
                    Button(action: {
                        self.selected = element
                        self.active = true
                    }) { self.content(element) }
                }
            }
        }
    }
}

struct HomeView: View {
    @State var dataTypes: [DataType] = {
        return (0...99).map{
            return DataType(i: $0)
        }
    }()
    
    var body: some View {
        NavigationView{
            ForEachLazyNavigationLink(data: dataTypes, destination: {
                return AnotherView(i: $0.i)
            }, content: {
                return HomeViewRow(dataType: $0)
            })
        }
    }
}

struct HomeViewRow: View {
    var dataType: DataType
    
    var body: some View {
        Text("Home View \(dataType.i)")
    }
}

struct AnotherView: View {
    init(i: Int) {
        print("Init AnotherView \(i.description)")
        self.i = i
    }
    
    var i: Int
    var body: some View {
        print("Loading AnotherView \(i.description)")
        return Text("hello \(i.description)").onAppear {
            print("onAppear AnotherView \(self.i.description)")
        }
    }
}

Answer 4

我最近一直在努力解决这个问题（用于表单的导航行组件），这对我有用：

@State private var shouldShowDestination = false

NavigationLink(destination: DestinationView(), isActive: $shouldShowDestination) {
    Button("More info") {
        self.shouldShowDestination = true
    }
}

只需将Button 与NavigationLink 包装起来，即可通过按钮控制激活。

现在，如果您要在同一个视图中有多个按钮+链接，而不是为每个激活 State 属性，您应该依赖此初始化程序

    /// Creates an instance that presents `destination` when `selection` is set
    /// to `tag`.
    public init<V>(destination: Destination, tag: V, selection: Binding<V?>, @ViewBuilder label: () -> Label) where V : Hashable

https://developer.apple.com/documentation/swiftui/navigationlink/3364637-init

按照这个例子的思路：

struct ContentView: View {
    @State private var selection: String? = nil

    var body: some View {
        NavigationView {
            VStack {
                NavigationLink(destination: Text("Second View"), tag: "Second", selection: $selection) {
                    Button("Tap to show second") {
                        self.selection = "Second"
                    }
                }
                NavigationLink(destination: Text("Third View"), tag: "Third", selection: $selection) {
                    Button("Tap to show third") {
                        self.selection = "Third"
                    }
                }
            }
            .navigationBarTitle("Navigation")
        }
    }
}

更多信息（以及上面稍作修改的示例）取自 https://www.hackingwithswift.com/articles/216/complete-guide-to-navigationview-in-swiftui（在“程序化导航”下）。

或者，创建一个自定义视图组件（嵌入NavigationLink），例如这个

struct FormNavigationRow<Destination: View>: View {

    let title: String
    let destination: Destination

    var body: some View {
        NavigationLink(destination: destination, isActive: $shouldShowDestination) {
            Button(title) {
                self.shouldShowDestination = true
            }
        }
    }

    // MARK: Private

    @State private var shouldShowDestination = false
}

并将其作为Form（或List）的一部分重复使用：

Form {
    FormNavigationRow(title: "One", destination: Text("1"))
    FormNavigationRow(title: "Two", destination: Text("2"))
    FormNavigationRow(title: "Three", destination: Text("3"))
}

Answer 5

我发现解决此问题的最佳方法是使用惰性视图。

struct NavigationLazyView<Content: View>: View {
    let build: () -> Content
    init(_ build: @autoclosure @escaping () -> Content) {
        self.build = build
    }
    var body: Content {
        build()
    }
}

然后 NavigationLink 看起来像这样。您可以将要显示的视图放在()

NavigationLink(destination: NavigationLazyView(DetailView(data: DataModel))) { Text("Item") }

Answer 6

我遇到了同样的问题，我可能有一个包含 50 个项目的列表，然后为调用 API 的详细视图加载了 50 个视图（这导致下载了 50 个额外的图像）。

对我来说，答案是使用 .onAppear 来触发当视图出现在屏幕上时需要执行的所有逻辑（例如设置计时器）。

struct AnotherView: View {
    var body: some View {
        VStack{
            Text("Hello World!")
        }.onAppear {
            print("I only printed when the view appeared")
            // trigger whatever you need to here instead of on init
        }
    }
}