亲子关系协议和ObjC可用性

Question

我不能让下面的代码工作：

@objc protocol Child { } 

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

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

class ParentImpl: Parent { 
    let child = ChildImpl() 

    // 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() 
} 

我得到的错误：

Playground execution failed: error: Tests.playground:3:7: error: type 'ParentImpl' does not conform to protocol 'Parent' class ParentImpl: Parent { ^

Tests.playground:4:9: note: candidate has non-matching type 'ChildImpl' var child = ChildImpl()

基本上我有两个亲子协议，和两个实现这两个协议的类。但编辑仍然抱怨ChildImpl不是Child，这是不正确的。

我可以让错误消失，如果我对Parent

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

使用关联的类型，但我需要有可用的Objective-C的协议，同时还需要能够引用child为实际的具体类型。

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

Answer 1

如果你不介意将扩展属性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 

Answer 2

你ParentImpl类有没有孩子类型的协议。我解决了这个解决方案。

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

Answer 3

这对你有帮助吗？

protocol Child { } 

protocol Parent { 
    var child: Child { get } 
} 

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

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

Answer 4

这样做对你有用吗？

编辑：我刚刚注意到这个问题发布超过1年前。它此刻虽然热门问题...

//: Playground - noun: a place where people can play 

import UIKit 

@objc protocol Child { 
    func eat() 
} 

@objc protocol Parent: Child { 
// init() 
    func buyFood() 
} 

class Human {} 

class Person: Human, Parent { 

// required override init() {} 

    func buyFood() {} 

    func eat() {} 
} 

class Nursery { 

    let person: Human & Parent 

    init() { 
    person = Person() 
    } 

    func dinnerBell() { 
    person.buyFood() 
    person.eat() 
    } 
} 

//class School<T: Parent> { 
// 
// let parent = T() 
// 
// func dinnerBell() { 
// parent.buyFood() 
// parent.eat() 
// } 
//} 

class University { 

    let person = Person() 

    func dinnerBell() { 
    person.buyFood() 
    person.eat() 
    } 
} 

Answer 5

我提到在评论一个link显示你已经尝试过的东西，使用相关的类型或单独的属性只是履行协议一致性。我的事情斯威夫特很快将支持从组合类型推断类型，如let child: Child & ChildImpl = ChildImpl()或简单地child: ChildImpl因为ChildImpl是Child。但在此之前，我认为我建议另外一种选择，即将您需要的apis从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 6

你正在试图做的，什么叫covariance快捷不支持符合这些协议的协议或类/结构的协方差。 你要么必须使用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"