使用泛型实现命令模式

Question

我正在尝试实现命令模式，所以它的工作方式如下：

• 有一个基类Command<T>，所有其他命令都从该基类继承。
• 可以在派生自Actor 的类上执行命令。
• 每个接口都定义了Actor 可以执行的操作。例如。 IMovable 或 ITurnable。
• 每个命令类都作用于特定的接口。例如。 Command<IMovable>。
• Actor 实现接口，这些接口定义了它们可以执行的操作。

这是我尝试实现它的方法：

// base interface for all action interfaces
public interface ICommandable { }

// interface for a move action
public interface IMovable : ICommandable
{
    void Move();
}

// base actor class
public class Actor : ICommandable
{
    public void ExecuteCommand(ICommand<ICommandable> command)
    {
        (command as Command<ICommandable>).Execute(this);
    }
}

// an actor which can be moved
public class MovableActor: Actor, IMovable
{
    public void Move()
    {
        Console.WriteLine("Move");
    }
}

// an interface for commands
public interface ICommand<out T> { }

// base command class
public class Command<T> : ICommand<T> where T : ICommandable
{
    public virtual void Execute(T robot) { }
}

// move command
public class MoveCommand : Command<IMovable>
{
    public override void Execute(IMovable actor)
    {
        actor.Move();
    }
}

这是我正在尝试做的一个例子：

MovableActor actor = new MovableActor();
Command<IMovable> cmd = new MoveCommand();
actor.ExecuteCommand(cmd);

我的实现的问题是ICommand 接口必须使用out 关键字作为其参数。我做了一些阅读，我明白为什么会这样，但我不知道如何实现我所描述的。我该如何实现？

如果这不可能，我应该如何更改我的描述，使其尽可能接近这个，但有效？

Answer 1

这里的基本问题是您的MoveCommand.Execute 必须被赋予IMovable——该方法取决于拥有IMovable。但是，您可以向Actor.ExecuteCommand 传递任何内容，甚至是诸如ICommand<ITurntable> 之类的命令：没有什么能阻止您这样做。

但如果你这样做了，并用ICommand<ITurntable> 调用MoveCommand.ExecuteCommand，MoveCommand.Execute 会失败，因为它需要IMovable。

您的基本选择是：

1. 要么不让 Actor 对自己调用命令：直接在 Actor 上调用命令，或者让单独的 CommandInvoker 同时执行操作和命令
2. 准备好有人可能会向无法接受的参与者发送命令，并在运行时检查并处理它。然后它只是 Actor.ExecuteCommand(ICommand command)，然后您执行运行时检查以查看它是否是正确的命令类型。

看起来像：

// base interface for all action interfaces
public interface ICommandable { }

// interface for a move action
public interface IMovable : ICommandable
{
    void Move();
}

// base actor class
public abstract class Actor : ICommandable
{
    public void ExecuteCommand(ICommand command)
    {
        command.Execute(this);
    }
}

// an actor which can be moved
public class MovableActor: Actor, IMovable
{
    public void Move()
    {
        Console.WriteLine("Move");
    }
}

// an interface for commands
public interface ICommand
{
    void Execute(ICommandable robot);
}

// base command class
public abstract class Command<T> : ICommand where T : ICommandable
{
    void ICommand.Execute(ICommandable robot)
    {
        if (robot is T typedRobot)
        {
            Execute(typedRobot);
        }
        else
        {
            // Handle this error
        }
    }
    
    protected abstract void Execute(T robot);
}

// move command
public class MoveCommand : Command<IMovable>
{
    protected override void Execute(IMovable actor)
    {
        actor.Move();
    }
}