Implementar uma interface conforme demonstrado de forma simples e clara pelo dfa é limpo e elegante (e uma forma com suporte "oficial"). É para isso que se destina o conceito de interface.
Em C #, poderíamos usar delegados para programadores que gostam de usar ponteiros de função em c, mas a técnica do DFA é a maneira de usar.
Você também poderia ter um array
Command[] commands =
{
new CommandA(), new CommandB(), new CommandC(), ...
}
Então você pode executar um comando por índice
commands[7].exec();
Plagiando do DFA, mas tendo uma classe base abstrata em vez de uma interface. Observe o cmdKey que seria usado posteriormente. Por experiência, percebo que frequentemente um comando de equipamento também possui subcomandos.
abstract public class Command()
{
abstract public byte exec(String subCmd);
public String cmdKey;
public String subCmd;
}
Construa seus comandos assim,
public class CommandA
extends Command
{
public CommandA(String subCmd)
{
this.cmdKey = "A";
this.subCmd = subCmd;
}
public byte exec()
{
sendWhatever(...);
byte status = receiveWhatever(...);
return status;
}
}
Você poderia então estender HashMap ou HashTable genérico fornecendo uma função de sucção de par de valores-chave:
public class CommandHash<String, Command>
extends HashMap<String, Command>
(
public CommandHash<String, Command>(Command[] commands)
{
this.commandSucker(Command[] commands);
}
public commandSucker(Command[] commands)
{
for(Command cmd : commands)
{
this.put(cmd.cmdKey, cmd);
}
}
}
Em seguida, construa seu armazenamento de comando:
CommandHash commands =
new CommandHash(
{
new CommandA("asdf"),
new CommandA("qwerty"),
new CommandB(null),
new CommandC("hello dolly"),
...
});
Agora você pode enviar controles objetivamente
commands.get("A").exec();
commands.get(condition).exec();