ios - 回调违反控制反转

Question

如果我对 IOC 的理解正确，这意味着您配置的任何框架或模块都应该能够在需要时驱动您的代码(引用:Martin Flower IOC Blog)。这意味着控制是框架驱动的。

我正在浏览一个很棒的博客 Future and Promises in Combine .博客一开始就说通过回调或闭包处理异步行为违反了 IOC。我有点不同意这种说法，但只是想澄清我的理解。

场景:

我创建了一个 TestFramework 来为框架用户处理一些功能。

public class TestFramework {

    typealias UpdatedFrameworkData = (FrameworkData?) -> Void

    var giveUpdatedValues: (() -> UpdatedFrameworkData)?

    init() { }

    private func someAction() {
        var updatedValuesCallback = giveUpdatedValues?()
        updatedValuesCallback = { [weak self] updatedFrameworkData in
            // Perform some action

        }
    }
}

现在我有一个使用这个框架的类

class FrameworkUser {
    let framework: TestFramework = TestFramework()
    var updatedValuesCallback: TestFramework.UpdatedFrameworkData?

    init() {
       setupBinding()
    }

    private func setupBinding() {
        updatedValuesCallback = framework.giveUpdatedValues?()
    }

    private func getUpdatedData(completion: @escaping TestFramework.UpdatedFrameworkData) {
        // Return some data
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            self.updatedValuesCallback?(self.getFrameworkData())
        }
    }

    private func getFrameworkData() -> FrameworkData? {
        nil
    }
}

框架有时可能需要处理更新的数据而不是一些陈旧的数据。如果您观察到我的框架仍然可以控制何时通过用户提供的监听器获取更新数据的功能。用户通过异步回调向框架提供数据。

那么，在这种情况下，我是不是通过回调实现了 IOC，还是我遗漏了什么？

编辑:

我在上面的设置绑定(bind)代码中犯了一个小错误。用户仍然调用框架来提供更新的值。

我对上面的代码进行了以下修改，发现通过回调对程序进行异步处理确实违反了 IOC 原则。上面的 setupBinding() 方法在绑定(bind)到框架回调的方式上不正确。它应该是这样的:

private func setupBinding() {
        framework.giveUpdatedValues = {
            return getUpdatedData() // This won't work
        }
    }

为了遵循 IOC 原则，用户应该将其代码绑定(bind)到框架回调。上面的代码根本行不通，因为您不能简单地从函数返回一个转义闭包，而这个闭包将在稍后的某个时间线中执行。

Answer 1

闭包和协议(protocol)在语义上是相同的，即使它们在句法上不同。如果闭包违反了 IOC，那么协议(protocol)也是如此。由于 IOC 的经典示例使用协议(protocol)，这意味着在语义上相同的闭包不会违反协议(protocol)。

为了证明它们是一样的:

protocol FrameworkDelegate { 
    func myFunc(data: Int)
}

class Framework {
    weak var delegate: FrameworkDelegate?

    func example() {
        delegate?.myFunc(5)
}

对比

class Framework {
    var delegate: ((Int) -> Void)?

    func example() {
        delegate(5)
    }
}

上面两个代码示例之间的唯一区别是什么对象确保 delegate 不会 deinit。在这两种情况下，Framework 的用户定义发生了什么，而框架类型决定何时调用“委托(delegate)方法”。