How can I pass arguments to commands known by interface?

Question

Following is the state I want to achieve in a clean way:

As you can see, I have the problem that the Invoker only knows the Command interface, but want to invoke the ConcreteCommand. This implementation again needs some arguments from the Invoker.

Here is now the dirty solution I have used so far:

There are several problems I have with this solution:

• The Invoker has meta knowledge about the count and the types of the arguments of the commands.
• The Invoker uses magic strings to get the desired command.
• When the Invoker do not pass the correct arguments I get a runtime error. I would prefer compile errors.

What is the common approach to pass arguments to concrete commands, without breaking the loose coupling (e.g. the Invoker needs to know the ConcreteCommand)?

Regards, Yggdrasil

Answer 1

Use some kind of Factory to create/access the ConcreteCommands?

This way the Invoker only knows the Command interface, and the Factory knows how to pair it with a concrete implementation.

public class Factory {
  // Find by key, can vary implementation at runtime
  Command makeCommand(final String key);

  // Compile-safe invocation, but you can still vary implementation at runtime
  Command makeMySpecificCommand(); 
}

Answer 2

If your Invoker needs to send arguments to command and you really want to do it in type-safe way(which is not usually so easy if we are dealing with composition if objects rather than inheritance), then I would parameterize Invoker with type of arguments-parameters that it can call, so that now Invoker may call commands that support such type of parameters. Sthm like that.

public abstract class Command<T> where T:class
{
    public abstract void Execute(T par);
}

public class ConcreteCommand<T> : Command<T> where T : class
{
    private readonly Receiver<T> _receiver;

    public ConcreteCommand(Receiver<T> receiver)
    {
        _receiver = receiver;
    }

    #region Overrides of Command<T>
    public override void Execute(T par)
    {
        _receiver.MenuItemClick(par);
    }
    #endregion
}

public class Invoker<T> where T : class
{
    private readonly T par;
    private readonly Command<T> cmd;

    public Invoker(T par, Command<T> cmd)
    {
        this.par = par;
        this.cmd = cmd;
    }

    public void Invoke()
    {
        cmd.Execute(par);
    }
}

public class Receiver<T> where T : class 
{
    public void MenuItemClick(T e)
    {
        Console.WriteLine("Parameter types {0}", e.GetType().FullName);
    }
}

static internal class CmdBuilder
{
    public static Command<T> PrepareCommand<T>() where T : class
    {
        Receiver<T> rcv = new Receiver<T>();
        Command<T> cmd = new ConcreteCommand<T>(rcv);
        return cmd;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var cmd = CmdBuilder.PrepareCommand<EventArgs>();
        cmd.Execute(new EventArgs());

        Console.ReadKey(true);
    }
}

Other option is to use parameter-object. Since all commands "know" what type of parameters they are expecting they can cast it to specific realization of parameter-object. But that wouldn't give you compile errors

Answer 3

I can see 2 option here. First you may pass an argument in ConcreteCommand constructor and keep it as a property. Later Execute() method will use that property. the other option if you want to pass an argument from Invoker directly. You may change the ICommand interface to this Execute(IArgument arg) Each argument will be inherited from IArgument and lately will be converted to original type in ConcreteCommand implementation. if the current ConcreteCommand implementation cannot convert the argument to original type, say, ArgumentImpl it will skip Execute and yield to other ConcreteCommand implementation

Answer 4

Instead of sending arguments to the 'execute' method, you can pass them while creating the command instance.

public class Factory {

  Command createCommand(Object[] objs,String key){
     return new ConcreteCommand(objs,key);
  }

}