父子协议关系和 ObjC 可用性

Question

我无法让以下代码工作：

@objc protocol Child { }

@objc protocol Parent {
    var child: Child { get }
}
    
class ChildImpl: Child {
    // not part of the `Child` protocol
    // just something specific to this class 
    func doSomething() { }
}
    
class ParentImpl: Parent {
    let child = ChildImpl()

    func doSomething() {
        // need to be able to access `doSomething`
        // from the ChildImpl class
        childImpl.doSomething()
    }

    // this would solve the problem, however can't access the ChildImpl members
    // that are not part of the protocol
    // let child: Child = ChildImpl()
    // as well as this, however maintaining two properties is an ugly hack
    // var child: Child { return childImpl }
    // private let childImpl = ChildImpl()
}

我得到的错误：

类型“ParentImpl”不符合协议“Parent”。
是否要添加协议存根？

基本上我有两个父子协议和两个实现这两个协议的类。但是，编译器仍然无法识别 ChildImpl 是 Child。

如果我在 Parent 上使用关联类型，我可以消除错误

protocol Parent {
    associatedtype ChildType: Child
    var child: ChildType { get }
}

，但是我需要有可供 Objective-C 使用的协议，并且还需要能够引用 child 作为实际的具体类型。

是否有解决方案不涉及重写Objective-C 中的协议，或者不添加重复的属性声明只是为了避免问题？

Answer 1

简短的回答是否定的，当前的设计不适用于当前的 Swift 语言。

原因是var child: Child { get } 协议要求在幕后创建了一个存在容器，类似于ExistentialContainer<Child>。因此，任何符合协议的类型也必须声明一个相同类型的存在容器，而不是ExistentialContainer<Subtype>。

似乎存在容器不是协变的，因此暂时需要使用问题和其他答案中描述的解决方法。

Answer 2

现在我们有了 Swift 5.1，我发现一个几乎很好的解决方案是使用属性包装器：

@propertyWrapper
struct Hider<T, U> {
    let wrappedValue: T

    init(wrappedValue: T) {
        self.wrappedValue = wrappedValue
    }

    var projectedValue: U { return wrappedValue as! U }
}

@objcMembers class ParentImpl: NSObject, Parent {
    @Hider<Child, ChildImpl> var child = ChildImpl()
}

这样child 暴露为Child，$child 暴露为ChildImpl，这允许在ParentImpl 中使用非协议成员。

解决方案并不理想，因为我还没有找到一种方法来描述 T 应该是 U 的超类型。

Answer 3

您正在尝试做的事情称为 covariance 并且 swift 不支持协议或符合这些协议的类/结构中的协变。 您要么必须使用Type-Erassure，要么必须使用associatedTypes：

protocol Child { }

protocol Parent {
    associatedtype ChildType: Child
    var child: ChildType { get }
}

class ChildImpl: Child {
    func doSomething() {
        print("doSomething")
    }
}

class ParentImpl: Parent {
    typealias ChildType = ChildImpl
    let child = ChildImpl()

    func test() {
        child.doSomething()
    }
}
ParentImpl().test() // will print "doSomething"

这里是Parent 协议的一般用法的类型擦除父级：

struct AnyParent<C: Child>: Parent {
    private let _child: () -> C
    init <P: Parent>(_ _selfie: P) where P.ChildType == C {
        let selfie = _selfie
        _child = { selfie.child }
    }

    var child: C {
        return _child()
    }
}

let parent: AnyParent<ChildImpl> = AnyParent(ParentImpl())
parent.child.doSomething() // and here in Parent protocol level, knows what is child's type and YES, this line will also print "doSomething"

Answer 4

我在 cmets 中提到了 link，显示了您尝试过的内容，使用关联类型或单独的属性只是为了满足协议一致性。我认为 Swift 很快就会支持从 let child: Child & ChildImpl = ChildImpl() 或简单的 child: ChildImpl 这样的组合类型推断类型，因为 ChildImpl 是 Child。但在那之前，我认为我建议另一种选择，即将您需要的 api 与 ChildImpl 分开，并将它们放在 Child 继承的单独协议中。这样当 Swift 编译器支持这个特性时，你不需要重构，只需将其删除即可。

// TODO: Remove when Swift keeps up.
@objc protocol ChildTemporaryBase { }
private extension ChildTemporaryBase {
    func doSomething() {
        (self as? ChildImpl).doSomething()
    }
}

@objc protocol Child: ChildTemporaryBase { }

class ParentImpl: Parent {
    let child: Child = ChildImpl()
    func testApi() {
        child.doSomething?()
    }
}

Answer 5

您的 ParentImpl 类没有 Child 类型协议。我解决了这个解决方案。

class ParentImpl: Parent {
   var child: Child = ChildImpl()
}

Answer 6

如果您不介意向 ParentImpl 类添加扩展属性：

@objc protocol Child {}

@objc protocol Parent {
    var child: Child! { get }
}

class ChildImpl: Child { }

class ParentImpl: Parent {
    var child: Child!
}

extension ParentImpl {

    convenience init(child: Child?) {
        self.init()
        self.child = child
    }

    var childImpl: ChildImpl! {
        get { return child as? ChildImpl }
        set { child = newValue }
    }

}

let parent = ParentImpl(child: ChildImpl())
let child = parent.child