避免未经检查的演员表

Question

在以下情况下，我找不到避免未经检查的强制转换的方法

class EventBus {
    val eventToHandle: MutableMap<KClass<out Event>, Event.() -> Unit> = mutableMapOf()

    final inline fun <reified T : Event> register(noinline handler: T.() -> Unit) {
        @Suppress("UNCHECKED_CAST")
        eventToHandle[T::class] = handler as Event.() -> Unit
    }

    fun fire(event: Event) {
        eventToHandle[event::class]?.invoke(event)
            ?: throw IllegalStateException("Missing handler for class ${event::class}")
    }
}

我的目标是强制映射仅包含具有 Event（或其子类型之一）作为接收者的 lambda，但同时我想要参考 actual 的实现Event 注册 lambda 时。 通过这种方式，我可以使用他的实现成员，而无需每次都进行强制转换。

一个例子（requestId是RequestExpiredEvent的一个字段）：

eventBus.register<RequestExpiredEvent> {
            requestService.setExpiredByRequestId(requestId)
        }

我知道“消费者 lambda”没有协方差并且它们是逆变的，但我想是否有办法。 我发现一个丑陋的解决方法是：

    final inline fun <reified T : Event> register(crossinline block: T.() -> Unit) {
        val handler: Event.() -> Unit = { this as T; block(this) }
        eventToHandle[T::class] = handler
    }

谢谢

Answer 1

这是一个危险的演员阵容。 SomeEventSubtype.() -> Unit 不是 Event.() -> Unit 的子类型。反之亦然。

假设 Event 是一个开放类，并且你有这个子类：

class SubEvent: Event() {
    fun hello(): Unit {
        println("hello")
    }
}

现在你尝试投射它：

val hello: SubEvent.() -> Unit = SubEvent::hello
val helloCasted = hello as Event.() -> Unit

当您尝试调用helloCasted.invoke(Event()) 时，它会在尝试将您的事件转换为子事件时抛出 ClassCastException。您不能使用 Event 的任何实例作为输入来调用 hello，因为只有 SubEvent 具有要调用的 hello 函数。

如果您尝试隐式转换，编译器会捕获此错误：

val hello: SubEvent.() -> Unit = SubEvent::hello
val helloCasted: Event.() -> Unit = hello // compiler error

反之亦然。查看函数的输入时，您可以将类型层次结构视为倒置的。

val toStringFun: Event.() -> Unit = Event::toString
val toStringCasted: SubEvent.() -> Unit = toStringFun // OK

如果不在某处进行未经检查的强制转换，则无法解决此问题，因为您在地图中存储了不同类型的对象。但是您需要将您的投射移动到 fire 函数，以便它知道将它投射到什么。您可以将函数存储为类型 Any 在地图中，因为无论如何您都会投射它们。像这样的：

class EventBus {
    val eventToHandle: MutableMap<KClass<out Event>, Any> = mutableMapOf()

    inline fun <reified T : Event> register(noinline handler: T.() -> Unit) {
        eventToHandle[T::class] = handler
    }

    @Suppress("UNCHECKED_CAST")
    inline fun <reified T : Event> fire(event: T) {
        (eventToHandle[T::class] as? T.() -> Unit)?.invoke(event)
            ?: throw IllegalStateException("Missing handler for class ${event::class}")
    }
}