I believe I have solved this with thanks to the current 1pointer answer and generics. I'll update the answer below and add it to that. Thanks!

正在尝试创建命令总线

我正在努力在 Swift 中创建命令总线。我现在遇到的问题是我试图使这个东西足够通用以处理不同的命令，但结果在很多情况下我必须返回 Any ，这意味着我必须一直对所有内容执行代码内检查，我不确定我能做些什么。

代码

protocol Command { }

struct TestCommand: Command
{ 
    public let value: int = 1
}

protocol CommandHandler
{
    func execute(_ command: Command) -> Any?
}

struct TestCommandHandler: CommandHandler
{
    public func execute(_ command: Command) -> Any?
    {
         // First problem - I have to cast command as! TestCommand
         // due to the interface
    }
}

下面是命令总线，它基本上只是将给它的命令映射到处理程序并返回它。没有什么特别或复杂的。

struct CommandBus
{
    public let container: Container

    /// Added as closures so the commands are only resolved when requested
    private func commandMap() -> Array<[String: () -> (Any)]>
    {
        // TestCommand implements an empty protocol CommandProtocol
        return [
            [String(describing: TestCommand.self): { self.container.resolve(TestCommandHandler.self)! }]
        ]
    }

    /// Dispatch a command to the relevant command handler
    public func dispatch(_ command: Command) -> Any
    {
        let map = self.commandMap()
        let commandName = String(describing: command.self)
        let element = map.enumerated().first(where: { $0.element.keys.first == commandName })
        let elementIndex = map.index(element!.offset, offsetBy: 0)
        let commandHandler: CommandHandler = map[elementIndex].first!.value() as! CommandHandler

        return commandHandler.execute(command)!
    }
}

命令总线的唯一职责实际上是找出要调用的命令处理程序并返回结果。

问题

以下是我现在遇到的问题:

• 具体的命令处理程序总是必须检查我传入的对象是否属于特定的具体类型，并将其转换为 as。只是为了我可以使用它(在这种情况下，处理程序希望能够从命令中获取 value)
• 命令总线总是返回 Any所以无论我返回什么标量，都必须检查它们是否存在于创建命令并将其传递到命令总线的 Controller 中

那么 - 我可以使用泛型来解决这里的任何问题吗？这更多是架构问题还是 OO 问题？或者我所追求的基本上是不可能的，因为这是一种严格类型化的语言？

我认为我在这里明显遗漏了一些东西。我怎样才能创建我需要的东西，同时保留体面的类型，而不必在每一步都告诉编译器一切。这可能吗？

我试过的...

有人建议我也可以使用关联类型的协议(protocol)，但我不确定将它放在哪里或如何做。我还想到了一个“请求/响应”风格的东西，其中每个命令都返回一个响应，但这必须是一个协议(protocol)，它基本上把我带回到 Any问题。

我还尝试更改 CommandBus签名:public func retrieveHandler<T: CommandHandler>(_ command: Command) -> T .我现在必须通过类型声明将命令传递给函数:

let handler: ConcreteHandlerName = commandBus.retrieveHandler(command)

最佳答案

不确定这是否是您想要的，因为我不太了解您要实现的目标，但请看一下我放在一起的这个 Playground 代码:

import Foundation

protocol CommandProtocol {

    associatedtype Handler: CommandHandlerProtocol
    associatedtype Result

}

protocol CommandHandlerProtocol {

    associatedtype Command: CommandProtocol

    func execute(_ command: Command) -> Command.Result
    init()

}

class IntCommand: CommandProtocol {

    typealias Handler = IntCommandHandler
    typealias Result = Int
}

class IntCommandHandler: CommandHandlerProtocol {

    typealias Command = IntCommand

    func execute(_ command: Command) -> Command.Result {
        return 5
    }

    required init() { }
}

class StringCommand: CommandProtocol {

    typealias Handler = StringCommandHandler
    typealias Result = String
}

class StringCommandHandler: CommandHandlerProtocol {

    typealias Command = StringCommand

    func execute(_ command: Command) -> Command.Result {
        return "Hello!"
    }

    required init() { }
}

class CommandBus {

    public var map: [String: Any] = [:]

    func dispatch<T: CommandProtocol>(_ command: T) -> T.Handler.Command.Result {
        let handlerClass = map[String(describing: type(of: command))] as! T.Handler.Type
        let handler = handlerClass.init() as T.Handler
        return handler.execute(command as! T.Handler.Command)
    }

}

let commandBus = CommandBus()
commandBus.map[String(describing: IntCommand.self)] = IntCommandHandler.self
commandBus.map[String(describing: StringCommand.self)] = StringCommandHandler.self

let intResult = commandBus.dispatch(IntCommand())
print(intResult)

let stringResult = commandBus.dispatch(StringCommand())
print(stringResult)

更新

这是一个 CommandBus，它映射到处理程序的特定实例，而不仅仅是它的类型。这意味着可以删除 CommandHandlerProtocol 中的 init 方法。

我还隐藏了 map 属性，而是添加了一个方法来添加映射。这样在创建 map 时您的类型总是正确的:

protocol CommandHandlerProtocol {

    associatedtype Command: CommandProtocol

    func execute(_ command: Command) -> Command.Result

}

class CommandBus {

    private var map: [String: Any] = [:]

    func map<T: CommandProtocol>(_ commandType: T.Type, to handler: T.Handler) {
        map[String(describing: commandType)] = handler
    }

    func dispatch<T: CommandProtocol>(_ command: T) -> T.Handler.Command.Result {
        let handler = map[String(describing: type(of: command))] as! T.Handler
        return handler.execute(command as! T.Handler.Command)
    }

}

let commandBus = CommandBus()
commandBus.map(IntCommand.self, to: IntCommandHandler())
commandBus.map(StringCommand.self, to: StringCommandHandler())

let intResult = commandBus.dispatch(IntCommand())
print(intResult)

let stringResult = commandBus.dispatch(StringCommand())
print(stringResult)

关于swift - 接口(interface)返回任何？但混凝土返回具体的东西，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/52065876/