Behavioral Pattern - Command Pattern

Command pattern encapsulates a request as an object and gives it a known public interface. Command Pattern ensures that every object receives its own commands and provides a decoupling between sender and receiver. A sender is an object that invokes an operation, and a receiver is an object that receives the request and acts on it.

Command Pattern

  public class GarageDoor
    {
        public string Up()
        {
            return "Garage Door Is Open";
        }

        public string Down()
        {
            return "Garage Door Is Closed";
        }

        public string Stop()
        {
            return "Stop door";
        }

        public string LightOn()
        {
            return "light On";
        }

        public string LightOff()
        {
            return "light Off";
        }
    }

    public class Light
    {
        public string On()
        {
            return "Light is on";
        }
    }

    public interface Command
    {
        string execute();
    }

    public class GarageDoorOpenCommand : Command
    {
        GarageDoor objGarageDoor = new GarageDoor();
        public GarageDoorOpenCommand(GarageDoor tmpGarageDoor)
        {
            this.objGarageDoor = tmpGarageDoor;
        }

        public string execute()
        {
            return this.objGarageDoor.Up();
        }
    }

    public class GarageDoorClosedCommand : Command
    {
        GarageDoor garagedoor;
        public GarageDoorClosedCommand(GarageDoor tempGarageDoor)
        {
            this.garagedoor = tempGarageDoor;
        }

        public string execute()
        {
            return this.garagedoor.Down();
        }
    }

    public class LightOnCommand : Command
    {
        Light light;
        public LightOnCommand(Light argLight)
        {
            this.light = argLight;
        }

        public string execute()
        {
            return this.light.On();
        }
    }

    public class SimpleRemoteControl
    {
        Command slot;

        public void SetCommand(Command command)
        {
            this.slot = command;
        }

        public string ButtonPressed()
        {
            return this.slot.execute();
        }
    }

//************Client end************************************//
SimpleRemoteControl remotecontrol = new SimpleRemoteControl();
GarageDoor garagedoor = new GarageDoor();

//encapsulates a request as an object
GarageDoorOpenCommand objGarageDoorOpenCommand = new GarageDoorOpenCommand(garagedoor);
//Loaded the button slot with a "Garage Door Open Command"
remotecontrol.SetCommand(objGarageDoorOpenCommand);
//From the outside,no other objects really know what actions get performed on what recevier
Console.Write(remotecontrol.ButtonPressed() + "\n");

            
//encapsulates a request as an object
GarageDoorClosedCommand objGarageDoorClosedCommand = new GarageDoorClosedCommand(garagedoor);
//Loaded the button slot with a "Garage Door Closed Command"
remotecontrol.SetCommand(objGarageDoorClosedCommand);
//From the outside,no other objects really know what actions get performed on what recevier
Console.Write(remotecontrol.ButtonPressed() + "\n");

            
//encapsulates a request as an object
LightOnCommand objLight = new LightOnCommand(new Light());
//Loaded the button slot with a "Light On"
remotecontrol.SetCommand(objLight);
//From the outside,no other objects really know what actions get performed on what recevier
Console.Write(remotecontrol.ButtonPressed() + "\n");
                       
//Remote slot didn't care what command object it had, as long as it implemented the command interface
Console.ReadKey();