swift - 多次调用 Swift 闭包是否正确

Question

我正在设计一个 Swift API，我在其中定义了一个协议(protocol) EventTransmitter，其中包含一种传输一批 Events 的方法。处理一批 Events 可以以包含成功和失败事件的列表结束。

因此，此协议(protocol)的任何实现都应使用失败的事件和/或成功的事件来调用完成。

public enum EventResult {

    /// When the event was transmitted correctly.
    case success([Event])

    /// When the event failed and should be discarded
    case failure([Event])
}

public protocol EventTransmitter {

    func transmit(events: [Event], completion: @escaping (EventResult) -> Void)
}

有了上面的协议(protocol)，谁实现了协议(protocol)就得调用完成两次:

public class HTTPTransmitter: EventTransmitter {

    public func transmit(events: [Event], completion: @escaping (EventResult) -> Void) {

        let failedEvents =  ...
        let successEvents = ...

        completion(.failure(failedEvents))

        completion(.success(successEvents))
    }
}

用法是

transmitter.transmit(events: events, completion: { result in
    switch result {
    case .success(let events):
        // handle success events
    case .failure(let events):
        // handle failed events
    }
})

要求多次调用一个完成闭包是否正确？

或者对每种情况使用不同的闭包是否更合适:

public protocol EventTransmitter {

    typealias EventCallback = (([Event]) -> Void)

    func transmit(events: [Event], onSuccess: @escaping EventCallback, onFailure: @escaping EventCallback)
}

Answer 1

如果你想做这样的事情，其中​​可能会发生失败事件和成功事件的列表，那么我可能会将它们组合到同一个回调中......

回调类似...

typealias EventCallBack = (succeeded: [Event], failed: [Event]) -> ()

那么你只需要调用一次回调。

如果您有一个捕获回调状态的枚举，那么我建议只让它运行一次。

这纯粹是从 API 的角度来看的。处理一次成功两次是什么意思？还是三遍？或成功然后失败与失败然后成功相比。等等……

当然，您可以多次调用它，有些地方您可能想要调用。例如，存储闭包并调用它以响应用户交互或其他内容。

但是对于像这样只有一个请求的情况，我建议使用所有必要的信息调用一次。

另一种可能的选择

也许您可以将 success 和 failure 闭包处理合并到 Event 本身。

这样，如果事件失败，您可以调用 event.failed()，如果成功... event.succeeded() 或其他。

我不知道在这种特定情况下这是否是个好主意，但这肯定是另一种选择 :D

由 vacawama 建议

你也可以像这样定义你的枚举

enum EventResult {
    case success(Event)
    case failed(Event)
}

然后让你的回调像...

([EventResult]) -> ()

那样的话，您只需使用包含所有单个结果的单个数组调用它一次。

如果结果的顺序与事件的顺序相同很重要，这将很有用。