title: In C# how do I properly implement the Command Design Pattern?
body: <p>I'm currently studying design patterns and I'm currently looking at the command pattern.</p>
  
  <p>Here is my current code:</p>
  
  <pre><code>// this is the receiver
  class Calculator : IReceiver
  {
      int x;
      int y;
  
      CommandOptions command;
  
      public Calculator(int x, int y)
      {
          this.x = x;
          this.y = y;
      }
  
      public void SetAction(CommandOptions command)
      {
          this.command = command;
      }
  
      public int GetResult()
      {
          int result = 0;
  
          switch(this.command)
          {
              case CommandOptions.ADD:
                  result = this.x + this.y;
                  break;
  
              case CommandOptions.SUBTRACT:
                  result = this.x - this.y;
                  break;
  
              case CommandOptions.MULTIPLY:
                  result = this.x * this.y;
                  break;
          }
  
          return result;
      }
  }
  
  // command
  abstract class Command
  {
      protected IReceiver receiver;
  
      public Command(IReceiver receiver)
      {
          this.receiver = receiver;
      }
  
      public abstract int Execute();
  }
  
  class AddCommand : Command
  {
      public AddCommand(IReceiver receiver) : base(receiver)
      {
      }
  
      public override int Execute()
      {
          reciever.SetAction(CommandOptions.ADD);
          return receiver.GetResult();
      }
  }
  
  enum CommandOptions
  {
      ADD,
      SUBTRACT,
      MULTIPLY
  }
  
  interface IReceiver
  {
      void SetAction(CommandOptions command);
      int GetResult();
  }
  
  
  class Program
  {
      static void Main(string[] args)
      {
          IReceiver receiver = new Calculator(500, 25);
  
          //#Issue:The SetAction() method of the receiver is accessible.
          //receiver.SetAction(CommandOptions.ADD);
          receiver.SetAction(CommandOptions.MULTIPLY);
          Command command = null;
  
          Console.Write("Enter option 1-3: ");
  
          int commandOption = int.Parse(Console.ReadLine());
  
          switch(commandOption)
          {
              case 1:
                  command = new AddCommand(receiver);
                  break;
  
              case 2:
                  command = new SubtractCommand(receiver);
                  break;
  
              case 3:
                  command = new MultiplyCommand(receiver);
                  break;
  
              default:
                  command = new AddCommand(receiver);
                  break;
          }
  
          Console.WriteLine(command.Execute());
          Console.ReadKey();
      }
  }
  </code></pre>
  
  <p>Notice that in my main method, I can access the <code>SetAction</code> method of the receiver which is capable of setting which command to use.</p>
  
  <p>My question is: does my implementation violate the purpose of the command pattern, and is my implementation wrong because I'm able to access it in my client code? If so, how can I improve this implementation.</p>