Swift泛型对象池子类回收时泛型类型推断异常问题求助

这个问题的核心在于Swift泛型的不变性以及方法调用时的静态类型推断。让我们一步步分析并解决它：

问题根源 #

当你调用Enemy2实例的die()方法时，该方法继承自父类Enemy，此时self的静态类型是Enemy，所以containerPool.recycle(self)会触发ContainerPool的recycle<T: Poolable>(_ object:T)方法，其中泛型参数T被推断为Enemy。

而实际对象是Enemy2，concreteType = type(of: object)得到的是Enemy2.self，对应的池是Pool<Enemy2>。但Pool<Enemy2>和Pool<Enemy>是完全独立的类型（Swift泛型默认是不变的，子类泛型容器不会被视为父类泛型容器的子类），导致pool(for: concreteType)返回的Pool<Enemy2>无法匹配recycle<T>方法中期望的Pool<Enemy>，最终引发类型转换崩溃。

解决方案1：父类方法中强制转换为Self类型 #

最简单的修复方式是在父类Enemy的die()方法中，将self强制转换为Self类型。Self在实例方法中会动态绑定到实际的子类类型，这样recycle方法的泛型参数会被正确推断为子类类型：

class Enemy : Poolable {
    func die() {
        // 强制转换为Self，让泛型推断匹配实际子类类型
        containerPool.recycle(self as! Self)
    }
    
    // 实现Poolable协议的其他方法
    required init() {}
    func onRecycled() {}
    func willBeObtained() {}
}

这个转换是安全的，因为self的实际运行时类型就是Self（对于子类实例来说，Self就是子类本身），不会出现转换失败的情况。

解决方案2：修改ContainerPool的recycle方法（更通用） #

如果你不想修改每个父类的方法，可以调整ContainerPool的recycle实现，绕开静态泛型推断，直接基于对象的实际运行时类型处理：

首先，将ContainerPool中的pools存储从字符串键改为ObjectIdentifier，避免字符串命名冲突：

class ContainerPool {
    // 使用ObjectIdentifier作为键，比字符串更可靠
    var pools:[ObjectIdentifier:Any] = [:]
    
    // ... 其他方法保持不变，除了pool和preload中的键处理
    
    func pool<T:Poolable>(for type:T.Type, initialSpawn:Int = 10) -> Pool<T> {
        let id = ObjectIdentifier(type)
        if let pool = pools[id] as? Pool<T> {
            return pool
        }
        let pool = Pool<T>(initialSpawn:initialSpawn)
        pools[id] = pool
        return pool
    }
    
    func preload<T:Poolable>(type:T.Type, size:Int = 20){
        let _ = pool(for: type, initialSpawn: size)
    }
    
    // 修改recycle方法，不依赖静态泛型推断
    func recycle(_ object: Poolable) {
        let concreteType = type(of: object)
        let id = ObjectIdentifier(concreteType)
        guard let pool = pools[id] else {
            print("No pool found for type: \(concreteType)")
            return
        }
        
        // 通过泛型辅助函数动态处理类型匹配
        func recycleHelper<T: Poolable>(_ pool: Pool<T>) {
            if let typedObject = object as? T {
                pool.recycle(typedObject)
            }
        }
        
        // 利用Swift的动态类型转换，将pool绑定到正确的泛型版本
        switch pool {
        case let typedPool as Pool<Enemy>:
            recycleHelper(typedPool)
        case let typedPool as Pool<Enemy2>:
            recycleHelper(typedPool)
        // 新增子类时需要添加对应的case，或者用更通用的反射方式
        default:
            // 反射方式获取泛型参数，兼容所有Poolable子类
            let mirror = Mirror(reflecting: pool)
            if let genericArg = mirror.children.first?.value as? Poolable.Type {
                // 动态创建泛型辅助函数
                let helper: (Any) -> Void = { [pool] obj in
                    if let typedObj = obj as? genericArg {
                        (pool as! Pool<Poolable>).recycle(typedObj as! Poolable)
                    }
                }
                helper(object)
            }
        }
    }
}

这种方式更通用，不需要修改业务类的代码，但反射部分的实现稍复杂。如果你的项目中有大量Poolable子类，反射方式可以避免每次新增子类都修改switch语句。

额外建议 #

• 避免使用字符串作为池的键，改用ObjectIdentifier可以避免不同模块中同名类型的冲突问题。
• 在Pool类中可以添加边界检查，比如回收对象时验证类型是否匹配池的泛型类型，提前发现错误。

内容的提问来源于stack exchange，提问作者Jordi Puigdellívol