propertyWrapper下标未调用。为什么？

Question

我正在实现自己的atomicdictionary属性包装器如下：

@propertyWrapper
public class AtomicDictionary<Key: Hashable, Value>: CustomDebugStringConvertible {
  public var wrappedValue = [Key: Value]()

  private let queue = DispatchQueue(label: "atomicDictionary.\(UUID().uuidString)",
                                    attributes: .concurrent)

  public init() {}

  public subscript(key: Key) -> Value? {
    get {
      queue.sync {
        wrappedValue[key]
      }
    }

    set {
      queue.async(flags: .barrier) { [weak self] in
        self?.wrappedValue[key] = newValue
      }
    }
  }

  public var debugDescription: String {
    return wrappedValue.debugDescription
  }
}

现在，当我使用它的使用如下：

class ViewController: UIViewController {
  @AtomicDictionary var a: [String: Int]

  override func viewDidLoad() {
    super.viewDidLoad()
    self.a["key"] = 5
  }
}

atomicdicationary的订阅函数未调用！

有人对为什么这样做有任何解释吗？

Answer 1

属性包装器 仅提供基本访问者方法，基本访问者方法，但就是这样。它不会拦截下标或其他方法。

原始属性包装纸提案向我们展示了幕后发生的事情。它考虑了一个假设的属性包装器，懒惰，其中：

属性声明

  @lazy var foo = 1738
 

转换为：

  private var _foo：lazy＆lt; int＆gt; = Lazy＆lt; int＆gt;（包装值：1738）
var foo：int {
    获取{return _foo.wrappedvalue}
    设置{_foo.wrappedvalue = newValue}
}
 

请注意，foo只是int计算属性。 _foo是Lazy＆lt; int＆gt;。

因此，在您的A [“ KEY”] = 5示例中，它不会使用您的属性包装器的下标操作员。它将获取与a关联的值，使用字典自己的下标操作员更新该值（而不是属性包装器的下标运算符），然后将设置与a关联的值。

这就是所有属性包装器所做的，提供get和set配件。例如，声明：

@AtomicDictionary var a: [String: Int]

转换为：

private var _a: AtomicDictionary<String, Int> = AtomicDictionary<String, Int>(wrappedValue: [:])
var a: [String: Int] {
    get { return _a.wrappedValue }
    set { _a.wrappedValue = newValue }
}

您定义的任何其他方法仅通过_a在本示例中访问，而不是a（这只是一个计算属性BrappedValue _a）。

---

因此，最好只是为“原子词典”定义适当的类型：

public class AtomicDictionary<Key: Hashable, Value> {
    private var wrappedValue: [Key: Value]
    
    private let queue = DispatchQueue(label: "atomicDictionary.\(UUID().uuidString)", attributes: .concurrent)
    
    init(_ wrappedValue: [Key: Value] = [:]) {
        self.wrappedValue = wrappedValue
    }
    
    public subscript(key: Key) -> Value? {
        get {
            queue.sync {
                wrappedValue[key]
            }
        }
        
        set {
            queue.async(flags: .barrier) {
                self.wrappedValue[key] = newValue
            }
        }
    }
}

这

let a = AtomicDictionary<String, Int>()

为您提供了想要的行为。

---

而且，如果您要提供CustomDebugStringConvertible一致性，请确保在此处使用您的同步机制：

extension AtomicDictionary: CustomDebugStringConvertible {
    public var debugDescription: String {
        queue.sync { wrappedValue.debugDescription }
    }
}

所有与包装值的交互都必须同步。

---

显然，您可以将此通用模式与所需的任何同步机制一起使用，例如上述阅读器撰写的模式，GCD串行队列，锁，演员等（读取器撰写的模式具有自然吸引力，但实际上，在那里， 的机制。

---

通常是更好 人们应该始终对通用线程安全集合保持警惕，因为我们代码的正确性依赖于更高级别的同步。