public interface IComando
{
int Executa(int x, int y);
}
public interface IReceptor
{
int X { get; set; }
int Y { get; set; }
int Calcular(int comandoOption);
}
public class AddCommand : IComando
{
public int Executa(int x, int y)
{
return x + y;
}
}
public class MultiplyCommand : IComando
{
public int Executa(int x, int y)
{
return x * y;
}
}
public class SubtractCommand : IComando
{
public int Executa(int x, int y)
{
return x - y;
}
}
public class ComandoFactorry
{
public IComando GetComando(int comandoOption)
{
switch (comandoOption)
{
case 1:
return new AddCommand();
case 2:
return new SubtractCommand();
case 3:
return new MultiplyCommand();
default:
return new AddCommand();
}
}
}
public class Calculadora : IReceptor
{
public int X { get; set; }
public int Y { get; set; }
public Calculadora(int x,int y)
{
X = x;
Y = y;
}
public int Calcular(int comandoOption)
{
IComando Comando = new ComandoFactorry().GetComando(comandoOption);
return Comando.Executa(X, Y);
}
}
class Program
{
static void Main(string[] args)
{
IReceptor receptor = new Calculadora(40, 20);
Console.Write("Escolha sua opcao de 1 a 3: ");
int comandOption = int.Parse(Console.ReadLine());
Console.WriteLine(receptor.Calcular(comandOption));
Console.ReadKey();
}
}
4
respostas
respostas
Olá, fiz esse código referente ao padrão Command. Motivação: Tenho uma calculadora que recebe 2 números inteiros e precisa fazer algumas operações.
Qual a pergunta?
Apenas gostaria de saber se o exemplo do código que eu fiz está correto para o padrão ??
Tem tabulação em excesso nas chaves após as especificações de suas classes. Deixe assim, com as chaves abrindo alinhada ao inicio da especificação da classe:
public interface IComand
{O restante parece ok.
Oi Maurício, eu acho que essa implementação do design Command não está legal.
Veja que no código cada IComando está executando a operação de cálculo:
public class MultiplyCommand : IComando
{
public int Executa(int x, int y)
{
return x * y;
}
}Quando você faz return x * y;, o próprio comando está tomando pra si o papel que seria da calculadora. Ou seja, se você der uma olhada, vai perceber que sua calculadora não está calculando nada, pois esse papel está sendo representado pelos comandos.
Então o que fazer? Você pode mudar os comandos para que eles 1) recebam no construtor uma instância da calculadora e do operando e 2) invoquem a operação desejada na classe Calculadora ("receiver" ou "receptor"):
public class MultiplyCommand : IComando
{
private readonly IReceptor calculadora;
private readonly int operando;
public MultiplyCommand (IReceptor calculadora, int operando)
{
this.calculadora = calculadora;
this.operando = operando;
}
public void Executa()
{
this.calculadora.Multiplica(this.operando);
}
}Ou seja, é o comando que deve delegar a operação para a calculadora, e não o contrário.
E note que eu só armazenei um dos 2 operadores na classe MultiplyCommand: isso porque estou pressupondo que o outro operando é o próprio valor atual da classe Calculadora.