4
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.

 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

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.