Question

假设我的（极其简化）的应用程序代码如下：

// Foo.swift
protocol FooDelegate: class {
    func didBar(on foo: Foo)
}

class Foo {
    weak var delegate: FooDelegate?
}

private extension Foo {
    func _bar() {
        self.delegate?.didBar(on: self)
    }
}

// Baz.swift

class Baz: FooDelegate {
    init() {
        let foo: Foo = Foo()
        foo.delegate = self
        self._foo = foo
    }

    private var _foo: Foo

    func didBar(on foo: Foo) {
        print("Bazinga!")
    }
}

由于Foo.swift之外的任何东西都不会读取任何Foo实例的.delegate，因此我可以这样修改Foo：

// Foo.swift
protocol FooDelegate: class {
    func didBar(on foo: Foo)
}

extension Foo {
    func setDelegate(_ delegate: FooDelegate?) {
        self._delegate = delegate
    }
}

class Foo {
    private weak var _delegate: FooDelegate?
}

private extension Foo {
    func _bar() {
        self._delegate?.didBar(on: self)
    }
}

我可以想到以下问题：

要编写的代码要多一些（实际上，与我通常编写的方式相比要少一些，请参见下文）
如果要对类型进行子类化并想在子类的实现中使用委托，则必须在Foo.swift中实现需要使用委托的子类部分，或使内部可以访问委托变量。再次

这还有其他可能的缺点吗？

如果代码位于框架而不是应用程序中，则我肯定会公开该变量，因此可以在类型的子类中使用它。在我的应用程序代码中，我只想让它在实际必要时才可读取，而在我正在使用的20000 loc应用程序中，从来没有。

我通常怎么写：

// Foo.swift
protocol FooDelegate: class {
    func didBar(on foo: Foo)
}

extension Foo {
    var delegate: FooDelegate? {
        get { return self._delegate }
        set { self._delegate = newValue }
    }
}

class Foo {
    private weak var _delegate: FooDelegate?
}

private extension Foo {
    func _bar() {
        self.delegate?.didBar(on: self)
    }
}

之所以这样做，是因为与在类声明中都具有私有和内部可访问变量相比，恕我直言，它使在类型的内部/公共接口上进行快速概述更为容易。在这种情况下，它只是一个变量，但假设您有一个类型，该类型具有10个内部可访问变量，另外5个仅可私有访问变量，这些变量中的一些是弱变量，有些是惰性的，也许还有一些静态变量，一些覆盖（也需要在类声明中声明）和一些初始化程序。

将setter函数用于从未在类外读取的变量是否有缺点？

0 个答案: