ios - 父子类之间的弱引用

Question

我们能否像下面的代码那样在类之间进行通信，而不是使用委托(delegate)/协议(protocol)模式和通知。我还没有看到任何这样的代码示例。但只是想知道为什么这会起作用或不起作用。

class Class1 {

    var class2Obj: Class2 = Class2()
    init() {
      class2Obj.class1Obj = self
    }

    func class1Method() {
       print("Parent")
    }
}

class Class2 {

   weak var class1Obj: Class1?

   func class2Method() {
      class1Obj.class1Method()
   }

}

Answer 1

这里的是委托(delegate)模式。您的委托(delegate)属性仅称为 class1Obj 而不是更习惯的 delegate 名称。这里的关键问题是您没有使用协议(protocol)，因此这两个类“紧密耦合”，即 Class2 高度依赖于 Class1 实现。此外，对于这两个紧密耦合的类，尚不清楚 Class2 可能需要 Class1 的哪些方法。它使 Class1 的维护变得更加困难，因为很容易意外做出破坏 Class2 行为的更改。这也使得很难将 Class2 与 Class1 以外的其他类一起使用。

相反，您通常会声明一个协议(protocol)来精确阐明 Class2 与可能需要使用它的其他对象之间的契约性质。结果是这些类的耦合度降低了，即 Class2 不需要知道其他类的任何信息，除了它是否符合所讨论的协议(protocol)。此外，在编辑 Class1 时，如果声明它符合协议(protocol)，当您未能实现某些必需的方法或属性时，编译器会警告您。

因此，通过微不足道的前期工作量，该协议(protocol)使代码更易于维护。它还提供了一些额外的灵 active ，您将来可以将 Class2 与 Class1 以外的其他内容结合使用。

归根结底，协议(protocol)可以使代码更易于维护、更灵活，并且没有隐藏的假设。

---

如果您不想使用委托(delegate)协议(protocol)模式，另一种选择是使用闭包，其中 Class1 提供了一个代码块，Class2 可以调用.所以你可以这样做:

class Class1 {

    var class2Obj = Class2()

    init() {
        class2Obj.handler = { [weak self] in     // note `weak` reference which avoids strong reference cycle
            self?.class1Method()
        }
    }

    func class1Method() {
        print("Parent")
    }
}

class Class2 {

    var handler: (() -> Void)?

    func class2Method() {
        handler?()
    }

}

委托(delegate)协议(protocol)模式在两个类之间有丰富的接口(interface)时很有用，而闭包模式在两个类之间有非常简单的接口(interface)时很有用。

坦率地说，上面的一个更常见的排列是闭包更直接地与 Class1 在 Class2 中发起的某些特定请求相关联。因此，您可以将参数设为 Class2 中适当方法的闭包。此外，您经常传回数据，因此假设我们传回一个可选的 String:

class Class1 {

    var class2Obj = Class2()

    func performClass2Method() {
        class2Obj.class2Method { string in
            guard let string = string else { return }

            self.class1Method()
        }
    }

    func class1Method() {
        print("Parent")
    }
}

class Class2 {

    func class2Method(completionHandler: @escaping (String?) -> Void) {
        // do something which creates `string`

        // when done, call the closure, passing that `string` value back

        completionHandler(string)
    }

}

这些闭包模式是在对象之间进行简单接口(interface)的好方法，但也使两个类保持非常松散的耦合(即 Class2 不依赖于 Class1)，很多就像在委托(delegate)模式中使用协议(protocol)一样。但希望上面的闭包示例说明了丰富委托(delegate)协议(protocol)模式的简单替代方案。