Swift中如何让父类泛型与属性泛型类型匹配？

一、编译错误原因 #

你遇到的编译错误是因为any PropertyGenericsProtocol属于存在类型（Existential Type），编译器无法确定它的关联类型SuccessA和FailureA的具体类型，因此无法解析propertyMethod所需的Result参数类型。必须将父类的泛型与协议的关联类型做强绑定，让编译器明确类型关系。

二、修正核心代码 #

将父类的泛型约束改为依赖协议的具体实现类型，而非单独声明SuccessB和FailureB，这样就能自动关联协议的关联类型：

protocol PropertyGenericsProtocol {
    associatedtype SuccessA
    associatedtype FailureA: Error
    
    func propertyMethod(completion: (Result<SuccessA, FailureA>) -> Void)
    func propertyMethodNoGenerics()
}

enum CustomError: Error {
    case invalid
}

class PropertyGenericsImpl: PropertyGenericsProtocol {
    typealias SuccessA = Bool
    typealias FailureA = CustomError // 修正原代码笔误：将FailureB改为FailureA
    
    func propertyMethod(completion: (Result<Bool, CustomError>) -> Void) {
        // 示例实现：返回成功结果
        completion(.success(true))
    }
    
    func propertyMethodNoGenerics() {
        print("调用无泛型方法")
    }
}

// 修正后的父类：通过泛型参数P绑定协议的具体实现
class ParentClass<P: PropertyGenericsProtocol> {
    typealias SuccessB = P.SuccessA
    typealias FailureB = P.FailureA
    
    var property: P
    
    init(property: P) {
        self.property = property
    }
    
    func main(completion: (Result<SuccessB, FailureB>) -> Void) {
        property.propertyMethodNoGenerics()
        
        // 现在可以正常调用，类型自动匹配
        property.propertyMethod { result in
            completion(result)
        }
    }
}

// 使用示例
let impl = PropertyGenericsImpl()
let parent = ParentClass(property: impl)
parent.main { result in
    switch result {
    case .success(let value):
        print("成功：\(value)")
    case .failure(let error):
        print("失败：\(error)")
    }
}

三、子类化Operation的实现方案 #

针对你实际需求（子类化Operation并调用注入类的方法返回结果），可以自定义泛型Operation子类，结合信号量处理异步方法的等待逻辑：

import Foundation

// 自定义Operation子类，泛型约束绑定协议实现
class GenericOperation<P: PropertyGenericsProtocol>: Operation {
    private let property: P
    private var completionHandler: ((Result<P.SuccessA, P.FailureA>) -> Void)?
    private(set) var operationResult: Result<P.SuccessA, P.FailureA>?
    
    init(property: P, completionHandler: ((Result<P.SuccessA, P.FailureA>) -> Void)?) {
        self.property = property
        self.completionHandler = completionHandler
        super.init()
    }
    
    override func main() {
        guard !isCancelled else {
            let cancelledError = OperationError.cancelled as! P.FailureA // 若需强类型错误，可让P.FailureA兼容OperationError
            operationResult = .failure(cancelledError)
            completionHandler?(operationResult!)
            return
        }
        
        // 用信号量等待异步方法完成（Operation默认同步执行）
        let semaphore = DispatchSemaphore(value: 0)
        
        property.propertyMethod { [weak self] result in
            guard let self else { return }
            self.operationResult = result
            self.completionHandler?(result)
            semaphore.signal()
        }
        
        semaphore.wait()
    }
}

// 通用Operation错误类型
enum OperationError: Error {
    case cancelled
}

// 使用示例
let operationImpl = PropertyGenericsImpl()
let operation = GenericOperation(property: operationImpl) { result in
    switch result {
    case .success(let boolValue):
        print("Operation成功：\(boolValue)")
    case .failure(let error):
        print("Operation失败：\(error)")
    }
}

let queue = OperationQueue()
queue.addOperation(operation)

四、其他实现思路 #

1. Combine框架（iOS 13+）：将PropertyGenericsProtocol的方法转换为Publisher，在Operation中订阅并处理结果，无需手动管理信号量：

   // 扩展协议支持Combine
   import Combine
   extension PropertyGenericsProtocol {
       func propertyMethodPublisher() -> AnyPublisher<SuccessA, FailureA> {
           return Future { [weak self] promise in
               self?.propertyMethod(completion: promise)
           }.eraseToAnyPublisher()
       }
   }
   

   然后在Operation中使用Sink订阅Publisher，结合DispatchGroup等待完成。

2. Swift Concurrency（Swift 5.5+）：如果无需兼容旧版本，可以用Task在Operation的main方法中调用异步方法，用await等待结果，简化异步处理逻辑。

内容的提问来源于stack exchange，提问作者thelioncubofcintra