如何强制基于 NSObject 的基类的子类覆盖类级变量？

Question

再次完全重写此问题，希望将重点放在我要解决的问题上。

我们有以下类，由于我们无法控制的外部框架，需要我们实现ObjCProtocolRequiringBla，就像这样......

class FooBase : NSObject, ObjCProtocolRequiringBla {

    class var possibleValues:[String] {
        // Note: Use preconditionFailure, not fatalError for things like this.
        // At runtime, they both halt execution, but precondition(Failure)
        // only logs the message for debug builds. Additionally,
        // in debug builds it pauses in a debuggable state rather than crash.
        preconditionFailure("You must override possibleValues")
    }

    // This satisfies the objective-c protocol requirement
    final func getBla() -> Bla {
        let subclassSpecificValues = type(of:self).possibleValues
        return Bla(withValues:subclassSpecificValues)
    }
}

class FooA : FooBase
    override class var possibleValues:[String] {
        return [
            "Value A1",
            "Value A2",
            "Value A3"
        ]
    }
}

class FooB : FooBase
    override class var possibleValues:[String] {
        return [
            "Value B1",
            "Value B2",
            "Value B3",
            "Value B4"
        ]
    }
}

如您所见，possibleValues 用于getBla() 的实现。此外，它必须是该特定子类的所有实例所共有的，因此是类变量而不是实例变量。这是因为在代码的另一个地方，我们必须检索所有子类中所有可能的值，就像这样......

static func getAllPossibleValues:[String] {
    return [
        FooA.possibleValues,
        FooB.possibleValues
    ].flatMap { $0 }
}

如果FooBase 的子类没有实现possibleValues，我想弄清楚如何让编译器抱怨。

换句话说，我们怎样才能让这个报告成为编译时错误：

class FooC : FooBase
    // Doesn't override class var possibleValues
}

目前我知道的唯一方法是上述方法，使用preconditionFailure 或类似名称在基类中定义它，但这是运行时检查，而不是编译时，因此它不是最佳解决方案。

Answer 1

如果 FooBase 的子类没有实现 possibleValues，我想弄清楚如何让编译器抱怨。

你不能。显然，您可以将 possibleValues 之类的东西作为协议要求并尝试采用该协议，但如果 FooBase 本身实现了 possibleValues，则如果子类未能覆盖它，您将无法让 编译器 抱怨。这不是一个愚蠢的想法，可能有一些计算机语言可以为您提供一种方法，但 Swift 不是这样的语言。这就是为什么运行时解决方案是您所希望的最好的，这就是标准模式，如果您查看 UIPopoverBackgroundView 之类的东西，您就会看到。

Answer 2

您可以通过将 FooBase 类替换为扩展 NSObjectProtocol 的协议来解决此问题。这将强制任何实现您的协议的类必须是 NSObject 的子类，并且还必须实现您想要的属性和方法。

protocol foo: NSObjectProtocol {
    var someProp: String {get set}

    func someFunc() -> Void
}

要从 Objective-C 中使用协议，可以使用 @objc 注释，这至少适用于简单的场景，例如发送选择器 #selector() 作为参数。

@objc protocol foo: NSObjectProtocol {
  var someProp: String {get set}

  func someFunc() -> Void
}

以下代码运行良好

class fooClass: NSObject, foo {
  var someProp: String

  init(someProp: String) {
    self.someProp = someProp
  }

  func someFunc() {
    print("In someFunc with property: \(someProp)")
  }

  func timeIt() {
    let timer = Timer.scheduledTimer(timeInterval: 0,  
    target: self, selector: #selector(someFunc), userInfo: nil, repeats: false)
    print("timer created")
    timer.fire()
  }
}

func main() {
  let f = fooClass(someProp: "test")
  f.timeIt()
}

main()

Answer 3

也许是这样的？我没有敲定每一个细节，但我认为这涵盖了你的很多编程问题。如果您想进一步讨论它，让我们开始一个聊天室，而不是继续在这里发布无休止的 cmets。

// Just to get it to compile
class Bla { init(withValues: [String]) {} }
protocol ObjCProtocolRequiringBla {}

class FooContainer : ObjCProtocolRequiringBla {
    fileprivate var fooCore: FooProtocol

    fileprivate init(_ fooCore: FooProtocol) { self.fooCore = fooCore }

    // This satisfies the objective-c protocol requirement
    final func getBla() -> Bla { return fooCore.getBla() }
}

protocol FooProtocol {
    static var possibleValues:[String] { get }

    func getBla() -> Bla
}

class FooA : NSObject, FooProtocol {
    class var possibleValues:[String] {
        return [
            "Value A1",
            "Value A2",
            "Value A3"
        ]
    }

    func getBla() -> Bla {
        return Bla(withValues: FooA.possibleValues)
    }
}

class FooB : NSObject, FooProtocol {
    class var possibleValues:[String] {
        return [
            "Value B1",
            "Value B2",
            "Value B3",
            "Value B4"
        ]
    }

    func getBla() -> Bla {
        return Bla(withValues: FooB.possibleValues)
    }
}