Question

我想在我的课上有一个方便的方法：

class BaseEvent {
  class func on(executionHandler: (BaseEvent -> Void)) -> Handler<BaseEvent> {
    return Handler<BaseEvent>(executionHandler: executionHandler)
  }
}

这有一个缺点，即执行处理程序没有BaseEvent子类的正确类型。想象一下，我有一个名为JumpEvent的课程，它来自BaseEvent，在理想的世界中，我可以做到以下几点：

let handler = JumpEvent.on { event in
//Do something with jump event
}

不幸的是，该事件的类型为BaseEvent，并且必须是低估的。

我试过以下，没有运气：

class func on(executionHandler: (Self -> Void)) -> Handler<BaseEvent> {
return Handler<BaseEvent>(executionHandler: executionHandler)
}

class func on<T: Self>(executionHandler: (T -> Void)) -> Handler<BaseEvent> {
return Handler<BaseEvent>(executionHandler: executionHandler)
}

请注意，返回类型（Handler<BaseEvent>）不是很重要，只是执行处理程序的类型。

我当前的“解决方案”如下，需要手动重新定义子类中的方法，这显然不太理想：

class BaseEvent {
  class func on<T: BaseEvent>(executionHandler: (T -> Void)) -> Handler<T> {
    return Handler<T>(executionHandler: executionHandler)
  }
}

class JumpEvent: BaseEvent {
  override class func on<T: JumpEvent>(executionHandler: (T -> Void)) -> Handler<T> {
    return super.on(executionHandler)
  }
}

如果需要其他信息，请与我们联系。

谢谢你，诺亚

Answer 1

我最终重新考虑了我的实现，并通过泛型实现了预期的结果。这可能不适用于所有用例，但它适用于我的，因为子类与基类相同，除了它们的关联模型对象。因此BaseEvent和JumpEvent更改为：

protocol ModelType {
}

class Jump: ModelType {
}

class Event<T: ModelType> {
   class func on(executionHandler: (Event<T> -> Void)) -> Handler<T> {
      return Handler<T>(executionHandler: executionHandler)
   }
}

这使我可以重用像BaseEvent那样的功能，并且我不需要为每个模型对象创建一个新的子类。

使用当前类作为类型约束

1 个答案: