Custom build State

1. Property wrapper
1. nonmutating
1. DynamicProperty
1. Binding
1. Conclusions

@State是SwiftUI的众多支柱之一，一旦理解了，我们就会理所当然地在任何地方使用它。但是@State是什么?幕后发生了什么?

本文中，让我们尝试通过重建@State等方法来回答这些问题。

像往常一样，我无法访问实际的SwiftUI代码/实现:我们在这里找到的是对模仿原始@State行为的最佳猜测，在实际实现中可能会有更多的内容。

1. Property wrapper

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

@propertyWrapper
struct FSState {

}

属性包装器需要一个wrappedValue，允许我们读取/写入关联的值。
因为我们想要模拟@State，所以我们将属性包装器设置为V类型的泛型，并将原始值存储在一个内部value属性中:

@propertyWrapper
struct FSState<V> {
  // 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")，我们需要声明一个特殊的初始化式:

@propertyWrapper
struct FSState<V> {
  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)
  }
}

2. nonmutating

到目前为止，我们的定义与直接在视图中定义属性没有太大区别。如果我们从ContentView声明中删除@FSState，一切仍然工作得很好:

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

  var body: some View {
    Text(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()!
      }
    }
  }
}

不幸的是，这无法构建: 我们得到一个Cannot assign to property: 'self' is immutable error on the button action。

问题是给text赋值会改变ContentView。

对于结构体，我们可以声明mutating方法，但不能声明mutating计算属性(比如body)，也不能在其中调用mutating方法。

为了克服这个问题，我们不能改变ContentView，这意味着我们也不能改变FSState，因为我们的属性包装器只是另一个嵌套在我们视图中的值类型。

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

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

  ...
}

我们现在已经将Cannot assign to property: 'self' is immutable build error移除。

这是有意义的，因为我们承诺不改变结构体实例，但是我们设置了value = newValue，它在改变。

这就是Swift引用类型的作用:如果我们用类类型替换FSState的value属性，然后更新setter中的类实例，我们实际上并没有改变FSState(因为FSState只包含对该类的引用，它总是保持不变)。

让我们定义这个“容器”类类型:

final class Box<V> {
  var value: V

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

Box是一个泛型类，只有一个函数:保持和更新我们的值。

让我们让@FSState的声明利用这个类:

@propertyWrapper
struct FSState<V> {
  var box: Box<V>

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

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

通过这个更新，我们可以构建并运行我们的应用程序!

我们点击按钮，但看不到任何变化，如果我们设置断点，我们会看到一切正常:正确点击按钮设置和更新我们的状态，但新的挑战是让SwiftUI知道。

3. DynamicProperty

与SwiftUI有一组已知的视图原语类似，SwiftUI也有一组已知的发布者，每个视图都可以根据视图中定义的属性监听这些发布者。

SwiftUI团队在隐藏SwiftUI大量使用Combine方面做得惊人:当我们将视图属性与@State， @ObservedObject等关联时，SwiftUI将监听所有连接到每个属性包装器的publishers，这反过来告诉SwiftUI什么时候该重绘。

在我们的例子中，让我们通过使Box符合ObservableObject来使用@StateObject。 Combine将一个objectWillChange发布者关联到所有ObservableObject实例，然后我们可以通过调用*send()*将事件发送到SwiftUI:

final class Box<V>: 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<V> {
  @StateObject var box: Box<V>

  var wrappedValue: V {
    ...
  }

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

感谢这个更新，每次框的值变化:

an objectWillChange event is fired
and an observer (SwiftUI?) of box's publisher would know about it

运行代码，不幸的是，我们还没到那一步。虽然当我们的值发生变化时，新的publisher会发送事件，但我们仍然需要告诉SwiftUI:

从SwiftUI的角度来看，ContentView有一个类型为**FSState**的文本属性，这是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<V>: DynamicProperty {
  ...
}

有了这个最后的改变，让我们再次运行我们的应用程序:

生效了!

尽管添加了DynamicProperty一致性，我们仍然没有声明SwiftUI应该监听哪些属性:类似于视图等价性的工作方式，我怀疑SwiftUI使用Swift的反射遍历所有存储的属性，并寻找要订阅的已知属性包装器类型。

关于如何以这种方式使用反射的开源示例，请参考我对Apple的ArgumentParser实现的深入研究，其中使用了相同的方法来查找各种命令行参数。

4. Binding

属性包装器的一个可选特性是公开一个投影值:
投影值（projected）是查看属性包装器中存储的值的另一种方法，以不同的方式公开。

许多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，我们在@FSState中添加相同的投影值:

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

  var wrappedValue: V {
    ...
  }

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

  ...
}

现在，我们可以在绑定中使用@FSState了!

下面是@FSState的最终定义:

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

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

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

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

final class Box<T>: ObservableObject {
  var value: T {
    willSet {
      objectWillChange.send()
    }
  }

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

5. Conclusions

我们越是深入研究SwiftUI，就越能发现一个简单、优雅的API中隐藏着多么复杂的东西。

大多数开发人员都不需要担心幕后的工作方式，但是我不得不感谢为达到这个美丽的状态所做的所有努力。

我确信@FSState不像真实的@State那么完整:如果有什么我错过的东西，或者如果你对我忽略的东西有更多的见解，我很想知道!

原文链接

Kayouyou's Den

1. Property wrapper

2. nonmutating

3. DynamicProperty

4. Binding

5. Conclusions

How SwiftUI's Preference Keys are propagated