SwiftUI:@State原理解析

@State是SwiftUI的众多支柱之一,一旦理解了它,我们就会理所当然地认为它无处不在,毫不犹豫地使用。但是@State是什么呢?幕后发生了什么?
在本文中,让我们尝试通过重建@State等来回答这些问题。

因为我无法访问实际的swift代码/实现,我们将分析模仿原始@State行为

Property wrapper属性包装

首先,@State是一个属性包装器,简而言之,它是一个具有额外逻辑和存储的高级getter和setter。
让我们先定义我们的状态如下:

@propertyWrapper
struct FSState {

}

属性包装器需要一个wrappedValue,让我们可以读/写相关的值。
因为我们想要模拟@State,所以我们将属性包装器泛型到类型V上,并将原始值存储在内部value属性中:

@propertyWrapper
struct FSState {
  // This is where our value is actually stored.
  var value: V
  
  // And here are our getter/setters.
  var wrappedValue: V {
    get {
      value
    }
    set {
      value = newValue
    }
  }
}

最后,如果我们想提供与@State和所有其他属性包装器相同的语法(例如,@State var x = "hello"@State var x = "hello"),我们需要声明一个特殊的初始化方法:

@propertyWrapper
struct FSState {
  var value: V
  
  var wrappedValue: V {
    ...
  }

  init(wrappedValue value: V) {
    self.value = value
  }
}

有了这个定义,我们现在可以开始在视图中使用@FSState,例如:

struct ContentView: View {
  @FSState var text = "Hello Five Stars"

  var body: some View {
    Text(text)
  }
}
image1.png

nonmutating

到目前为止,我们的定义与在视图本身中直接定义属性没有太大区别。
如果我们从ContentView声明中删除@FSState,一切仍然运行良好:

struct ContentView: View {
  var text = "Hello Five Stars"

  var body: some View {
    Text(text)
  }
}
image1.png

让我们现在尝试用一个按钮来改变text文本,例如:

struct ContentView: View {
  @FSState var text = "Hello Five Stars"

  var body: some View {
    VStack {
      Text(text)

      Button("Change text") {
        text = ["hello", "five", "stars"].randomElement()!
      }
    }
  }
}

不幸的是,这不会build成功:我们会得到一个按钮操作错误提示Cannot assign to property: 'self' is immutable。问题是,分配的文本会改变ContentView

使用结构体,我们可以声明mutating的方法,但不能声明mutating的计算属性(如body),也不能在其中调用mutating的方法。
为了克服这个问题,我们不能改变ContentView,这意味着我们也不能改变FSState,因为我们的属性包装器只是嵌套在视图中的另一个值类型。

首先,让我们声明我们的属性包装器设置为nonmutating,它告诉Swift设置这个值不会改变我们的FSState实例:

@propertyWrapper
struct FSState {
  var value: V
  
  var wrappedValue: V {
    get { ... }
    nonmutating set { // our setter is now nonmutating
      value = newValue
    }
  }

  ...
}

现在我们已经将构建错误Cannot assign to property: 'self' is immutabletext转移到FSStatewrappedValue的setter方法中了。
这是有意义的,因为我们承诺不改变struct实例,但我们设置value = newValue,这是可变的。

这就是Swift引用类型的由来:如果我们用class类型替换FSStatevalue属性,然后在我们的setter方法中更新这个类实例,我们实际上并没有更改FSState(因为FSState只包含对该类的引用,它总是保持不变)。
让我们把"container"定义成class类型:

final class Box {
  var value: V

  init(_ value: V) {
    self.value = value
  }
}

Box是一个泛型类,只有一个函数:拥有和更新我们的值。
让我们利用这个类给@FSState声明一个属性:

@propertyWrapper
struct FSState {
  var box: Box

  var wrappedValue: V {
    get {
      box.value
    }
    nonmutating set {
      box.value = newValue
    }
  }

  init(wrappedValue value: V) {
    self.box = Box(value)
  }
}

更新后buildandrun我们的应用!

image2.gif

我们点击按钮,但没有看到任何变化,如果我们设置断点,我们将看到一切工作:点击按钮可以设置和更新我们的状态,但是SwiftUI并不知道。
没错,我们更新数据,但SwiftUI并不知道它应该监听这些变化,并重新绘制body,让我们接下来解决这个问题。

DynamicProperty

与SwiftUI中已知的基础视图类似,SwiftUI中每个视图都可以根据视图中定义的属性监听这些publisher。
SwiftUI团队在隐藏SwiftUI大量使用Combine方面做了很多的工作:当我们将一个视图属性与@State@ObservedObject等关联起来时,SwiftUI会监听连接到每个属性包装器的所有发布者,然后这些发布者会告诉SwiftUI什么时候重新绘制。

在我们的例子中,我们使用@StateObject来匹配BoxObservableObject。组合关联一个objectWillChangepublisher到所有ObservableObject实例,然后我们可以通过调用send()将事件发送到SwiftUI:

final class Box: ObservableObject {
  var value: V {
    willSet {
      // This is where we send out our "hey, something has changed!" event
      objectWillChange.send()
    }
  }

  init(_ value: V) {
    self.value = value
  }
}

有更简单的方法来声明它,但在本文中,我们试图通过尽可能多地删除“魔法”来了解事情是如何工作的。有更简单的方法来声明它,但在本文中,我们试图通过尽可能多地删除“魔法”来了解事情是如何工作的。

随着Box定义的更新,我们现在可以回到@FSState,并将@StateObject关联到Box属性:

@propertyWrapper
struct FSState {
  @StateObject var box: Box

  var wrappedValue: V {
    ...
  }

  init(wrappedValue value: V) {
    self._box = StateObject(wrappedValue: Box(value))
  }
}

由于每次更新box的值变化:

  • objectWillChange事件被触发
  • box的publisher将会监听到

让我们再次运行我们的应用程序:

image2.gif

不幸的是,我们还没到那一步。当我们的值发生变化时,新的发布者确实会发送事件,但是我们仍然需要告诉SwiftUI:从SwiftUI的角度来看,ContentView有一个类型为FSStatetext属性,这不是SwiftUI需要关注的。

要改变这一点,我们需要FSState遵守DynamicProperty协议,在文档中描述为An interface for a stored variable that updates an external property of a view.
这正是SwiftUI关注的!通过使FSState遵守DynamicProperty协议, SwiftUI将监听它的事件并在需要时触发重绘。
DynamicProperty只需要一个update()函数的实现,然而SwiftUI已经提供了它的默认实现,我们需要做的就是添加DynamicProperty的一致性,然后就可以了:

@propertyWrapper
struct FSState: DynamicProperty {
  ...
}

通过最后的修改,让我们尝试再次运行我们的应用程序:

image3.gif

终于可以了!尽管添加了与DynamicProperty一致的属性,我们仍然没有明确声明SwiftUI应该监听哪些属性:与view Equatable的工作方式类似,我怀疑SwiftUI使用Swift的反射来迭代所有存储的属性,并寻找要订阅的已知属性包装类型。

Binding

属性包装器的一个可选特性是公开一个投影值:投影值是存储在属性包装器中的值的另一种查看方式,以不同的方式公开。
许多SwiftUI视图使用绑定来引用和潜在地改变其他地方拥有和存储的值。一个例子是TextField,它使用了一个Binding:

struct ContentView: View {
  @FSState var text = ""

  var body: some View {
    VStack {
      TextField("Write something", text: $text) // TextField's text is a binding
    }
  }
}

如上所述,我们可以通过在属性名前加上$来调用关联属性,从而从@State获得绑定,这个符号真正做的是获取投影值而不是包装的值。
因此@State的投影值是@Binding的一个V类型的泛型值,让我们在@FSState中添加相同的投影值:

@propertyWrapper
struct FSState: DynamicProperty {
  @ObservedObject private var box: Box

  var wrappedValue: V {
    ...
  }

  var projectedValue: Binding {
    Binding(
      get: {
        wrappedValue
      },
      set: {
        wrappedValue = $0
      }
    )
  }

  ...
}

瞧,我们现在可以使用@FSState和绑定了!

image4.gif

下面是最终的@FSState定义:

@propertyWrapper
struct FSState: DynamicProperty {
  @StateObject private var box: Box

  var wrappedValue: V {
    get {
      box.value
    }
    nonmutating set {
      box.value = newValue
    }
  }

  var projectedValue: Binding {
    Binding(
      get: {
        wrappedValue
      },
      set: {
        wrappedValue = $0
      }
    )
  }

  init(wrappedValue value: V) {
    self._box = StateObject(wrappedValue: Box(value))
  }
}
final class Box: ObservableObject {
  var value: T {
    willSet {
      objectWillChange.send()
    }
  }

  init(_ value: T) {
    self.value = value
  }
}

总结

我们对SwiftUI研究得越多,它就越能说明在一个简单、优雅的API中隐藏着多少复杂性。@FSState不像真正的@State那样完整和强大!也许我们还有很多没考虑到的地方。

你可能感兴趣的:(SwiftUI:@State原理解析)