在 completionHandler 中使用泛型

Question

我有一个简单的应用程序，它使用自定义协议通过 TCP 套接字与服务器通信。我想实现类似 HTTP 的响应请求行为，从套接字层抽象出来。 所以我有简单的协议：

protocol ResponseType {
   init(with frame: SocketMessage)
}

还有一些例子：

struct MessageAck: ResponseType {
  var messageId: String
  init(with frame: SocketMessage) {
    messageId = frame.messageId
  }
}

我为发送请求创建了简单的协议：

protocol APIClient {
  func send<T: ResponseType>(request: SocketAPIRequest, completion:  ((Result<T>) -> Void)?)
}

enum SocketAPIRequest {
   case textMessage(messageId: String, ...)
   ...
}

最后：

enum Result<T> {
  case success(T)
  case failure(Error)
}

class SocketAPIClient: APIClient {
  typealias MessageId = String
  private var callbacks = [Receipt: ((Result<ResponseType>) -> Void)]()

  ...

  func send<T>(request: SocketAPIRequest, completion: ((Result<T>) -> Void)?) where T : ResponseType {
    ....
    callbacks[stompFrame.receiptId] = completion
    ....
  }
}

所以，当我想为每个请求存储回调，在收到应答后调用它，我得到了这样的错误：

Cannot assign value of type '((Result<T>) -> Void)?' to type '((Result<ResponseType>) -> Void)?'

我猜是混合类型和对象的问题，或者可能是别的什么。

Answer 1

Swift 泛型不是协变的（对于涉及复制元素的 Array 有特殊的硬编码异常）。这意味着Result<Apple> 不是Result<Fruit> 的子类型。有关原因的示例，请参阅 Swift Generics & Upcasting。

在您的情况下，什么会阻止您将 Result<MessageBody> 传递给期望 Result<MessageAck> 的回调？例如：

for callback in callbacks {
    callback(result)
}

对于任何给定类型的result，您怎么知道这在编译时是合法的？

编辑（更好的答案）：

您可以将类型隐藏在闭包中以获得所需的内容。试试这个：

class SocketAPIClient: APIClient {
    typealias MessageId = String
    private var callbacks = [Receipt: ((Result<SocketMessage>) -> Void)]() // <--- Change

    func send<T>(request: SocketAPIRequest, completion: ((Result<T>) -> Void)?) where T : ResponseType {

        // Store the closure we don't understand inside a closure we do
        callbacks[stompFrame.receiptId] = { result in
            switch result {
            case .success(let message):
                completion?(.success(T.init(with: message)))
            case .failure(let error):
                completion?(.failure(error))
            }
        }
    }
}

现在，与其尝试将T 直接保存在callbacks 中，不如将它保存在每个单独的闭包中，对类的其余部分隐藏，并且T 永远不会逃避这个函数。当您到达您在代码中调用callback 的任何位置时，只需将Result<SocketMessage> 传递给它，我假设您已经在某个地方。

---

旧答案：

解决问题的最简单方法是让回调始终传递 Result<Data> 并完全删除 T：

protocol APIClient {
    func send(request: SocketAPIRequest, completion: ((Result<Data>) -> Void)?)
}

然后将其留给MessageAck（在完成处理程序中）从原始数据中反序列化。

还有其他方法可以使用类型橡皮擦来实现所有这些，但它们要复杂得多，有时也非常繁琐。

Answer 2

你试过下面的签名吗

func send<T:ResponseType>(request: SocketAPIRequest, completion: ((Result<T>) -> Void)?){ ... }

仍然出现错误？

编辑 1： 或者也许你应该尝试这样的事情

protocol APIClient {
  associatedtype T
  func send(request: SocketAPIRequest, completion:  ((Result<T>) -> Void)?)
}

和，

class SocketAPIClient: APIClient {
  typealias MessageId = String
  typealias T = ResponseType
  private var callbacks = [Receipt: ((Result<ResponseType>) -> Void)]()

  ...

  func send(request: SocketAPIRequest, completion: ((Result<T>) -> Void)?) {
    ....
    callbacks[stompFrame.receiptId] = completion
    ....
  }
}