8

正如标题所示，我试图通过父视图（P）将数据从一个子视图（A）传递到另一个子视图（B）。

父视图如下所示：

@State var rectFrame: CGRect = .zero 

var body: some View {
    childViewA(rectFrame: $rectFrame)
    childViewB()
}

哪里childViewA得到一个CGRect需要的childViewB。

childViewA看起来像这样：

@Binding var rectFrame: CGRect

var body: some View {
    // Very long code where rectFrame is obtained and printed to console correctly
}

我如何传递rectFrame给childViewB? 尽管在和中都打印了正确的值，但CGRect.zero到目前为止我尝试过的所有内容都会返回。childViewBparentViewchildViewA

为了尝试将值传递给childViewB，我parentView这样重写：

@State var rectFrame: CGRect = .zero 

var body: some View {
    childViewA(rectFrame: $rectFrame)
    childViewB(rectFrame: $rectFrame.value)
}

具有childViewB以下结构：

var rectFrame: CGRect = CGRect.zero

var body: some View {

}

但这只是CGRect.zero每次打印。

我最近尝试过@ObjectBinding，但我一直在努力，所以如果有人可以帮助我解决这个具体的例子，我将非常感激。

class SourceRectBindings: BindableObject {
    let willChange = PassthroughSubject<Void, Never>()

    var sourceRect: CGRect = .zero {
        willSet {
            willChange.send()
        }
    }
}
4

4 回答 4

7

您可以将EnvironmentObject用于此类...

EnvironmentObject的好处在于，无论何时何地您更改其中的一个变量，它都会始终确保在使用该变量的每个地方都进行了更新。

注意：要更新每个变量，您必须确保通过您希望更新的每个视图上的 BindableObject 类/EnvironmentObject...

源矩形绑定：

class SourceRectBindings: BindableObject {

    /* PROTOCOL PROPERTIES */
    var willChange = PassthroughSubject<Application, Never>()

    /* Seems Like you missed the 'self' (send(self)) */
    var sourceRect: CGRect = .zero { willSet { willChange.send(self) }
}

家长：

struct ParentView: view {
    @EnvironmentObject var sourceRectBindings: SourceRectBindings

    var body: some View {
        childViewA()
            .environmentObject(sourceRectBindings)
        childViewB()
            .environmentObject(sourceRectBindings)
    }
}

子视图A：

struct ChildViewA: view {
    @EnvironmentObject var sourceRectBindings: SourceRectBindings

    var body: some View {

        // Update your frame and the environment...
        // ...will update the variable everywhere it was used

        self.sourceRectBindings.sourceRect = CGRect(x: 0, y: 0, width: 300, height: 400)
        return Text("From ChildViewA : \(self.sourceRectBindings.sourceRect)")
    }
}

子视图B：

struct ChildViewB: view {
    @EnvironmentObject var sourceRectBindings: SourceRectBindings

    var body: some View {
        // This variable will always be up to date
        return Text("From ChildViewB : \(self.sourceRectBindings.sourceRect)")
    }
}

使其工作的最后步骤

• 进入您希望变量更新的最高视图，这是您的父视图，但我通常更喜欢我的SceneDelegate ...所以我通常这样做：

let sourceRectBindings = SourceRectBindings()

• 然后在同一个类中，'SceneDelegate' 转到我指定根视图的位置并通过我的 EnviromentObject

window.rootViewController = UIHostingController(
                rootView: ContentView()
                    .environmentObject(sourceRectBindings)
            )

• 然后对于最后一步，我将它传递给可能的父视图

struct ContentView : View {

    @EnvironmentObject var sourceRectBindings: SourceRectBindings

    var body: some View {
        ParentView()
            .environmentObject(sourceRectBindings)
    }
}

如果你像这样运行代码，你会看到你的预览会抛出错误。那是因为它没有通过环境变量。为此，只需启动一个类似于您的环境的虚拟实例：

#if DEBUG
struct ContentView_Previews : PreviewProvider {
    static var previews: some View {
        ContentView()
            .environmentObject(SourceRectBindings())
    }
}
#endif

现在您可以随心所欲地使用该变量，并且如果您想传递除 rect 之外的任何其他内容......您只需将变量添加到 EnvironmentObject 类，您就可以访问和更新它

于 2019-07-22T07:46:19.863 回答
4

您没有提到 ChildViewB 如何获得其矩形。也就是说，它是否使用 GeometryReader 或任何其他来源。无论您使用哪种方法，您都可以通过两种方式将信息向上传递到层次结构：通过绑定或通过首选项。如果涉及几何，甚至是锚偏好。

对于第一种情况，在没有看到您的实现的情况下，您可能会DispatchQueue.main.async {}在设置 rect 时丢失 a。这是因为更改必须发生在视图完成自身更新之后。但是，我认为这是一个肮脏、肮脏的把戏，只在测试时使用它，但从不在生产代码上使用。

第二种选择（使用首选项）是一种更强大的方法（并且是首选;-)。我将包含这两种方法的代码，但您应该明确了解更多有关偏好的信息。我最近写了一篇文章，你可以在这里找到：https ://swiftui-lab.com/communicating-with-the-view-tree-part-1/

第一种方法：我不建议将几何值向上传递到层次结构，这会影响其他视图的绘制方式。但如果你坚持，这就是你如何让它发挥作用：

struct ContentView : View {
    @State var rectFrame: CGRect = .zero

    var body: some View {
        VStack {
            ChildViewA(rectFrame: $rectFrame)
            ChildViewB(rectFrame: rectFrame)
        }
    }
}

struct ChildViewA: View {
    @Binding var rectFrame: CGRect

    var body: some View {
        DispatchQueue.main.async {
            self.rectFrame = CGRect(x: 10, y: 20, width: 30, height: 40)
        }

        return Text("CHILD VIEW A")
    }
}

struct ChildViewB: View {
    var rectFrame: CGRect = CGRect.zero

    var body: some View {
        Text("CHILD VIEW B: RECT WIDTH = \(rectFrame.size.width)")
    }
}

第二种方法：使用首选项

import SwiftUI

struct MyPrefKey: PreferenceKey {
    typealias Value = CGRect

    static var defaultValue: CGRect = .zero

    static func reduce(value: inout CGRect, nextValue: () -> CGRect) {
        value = nextValue()
    }
}

struct ContentView : View {
    @State var rectFrame: CGRect = .zero

    var body: some View {
        VStack {
            ChildViewA()
            ChildViewB(rectFrame: rectFrame)
        }
        .onPreferenceChange(MyPrefKey.self) {
            self.rectFrame = $0
        }

    }
}

struct ChildViewA: View {
    var body: some View {
        return Text("CHILD VIEW A")
            .preference(key: MyPrefKey.self, value: CGRect(x: 10, y: 20, width: 30, height: 40))
    }
}

struct ChildViewB: View {
    var rectFrame: CGRect = CGRect.zero

    var body: some View {
        Text("CHILD VIEW B: RECT WIDTH = \(rectFrame.size.width)")
    }
}
于 2019-07-22T07:36:28.697 回答
0

我希望我已经正确理解了您的问题，即在两个孩子之间共享信息。我采用的方法是在共享相同状态的两个子项中使用@Binding 变量，即用$rectFrame 实例化两者。这样，两者将始终具有相同的值，而不是实例化时的值。

在我的例子中，它是一个在一个子节点中更新并在另一个子节点中显示在列表中的数组，因此 SwiftUI 负责对更改做出反应。也许你的情况不是那么简单。

于 2019-07-25T09:01:55.397 回答
0

PhilipJacob 的回答很好，但是这个 API 有一个更新，我想我会提到它。

因此，如果您想使用BindableObject已重命名/更新为ObservableObject并且也var willChange变为var objectWillChange

所以他的答案变成了：

import Combine

class SourceRectBindings: ObservableObject {

    /* PROTOCOL PROPERTIES */
    var objectWillChange = PassthroughSubject<Void, Never>()

    /* Seems Like you missed the 'self' (send(self)) */
    var sourceRect: CGRect = .zero { willSet { objectWillChange.send(self) }
}
于 2021-09-23T20:26:03.317 回答