命令模式

1、   基本概述

　　问题：假设有一个控制器，该控制器上有7个可编程的插槽，每一个均可以指定到一个不一样的家电装置，每一个插槽都有对应的开关按钮。这个遥控器还具有一个总体的撤销按钮。厂家已经提供了控制家电基本处理类。但愿你可以建立一组控制遥控器的API，让每一个插槽都可以控制一个或一组装置。（以下图，厂商类）

 

　　分析1：厂家提供的类，有许多都具有On()和off()方法，除此以外还有一些其余的五花八门的方法。

　　分析2：还不仅这样，听起来彷佛未来还会有更多的厂商类，并且每一个类还会有各式各样的方法。

　　分析3：遥控器应该知道如何解读按钮被按下的动做，而后发出正确的请求，可是遥控器不需知道这些家电自动化的细节。

　　分析4：咱们不想让遥控器包含一大堆if语句，例如“if slot1==Light,then light.On(),else if slot1==Hottub,then hottub.JetsOn()”.你们都知道这样的设计很糟糕。且只要有新的厂商类进来，就必须修改现有的代码，形成潜在的错误。

　　分析5：命令模式能够将“动做的请求者”从“动做的执行者”对象中解耦，在这个例子中，请求者能够是遥控器，而执行者对象就是厂商类其中之一的实例。

　　分析6：利用命令对象，把请求（例如打开电灯）封装成一个特定对象（例如客厅电灯对象）。因此，若是对每一个按钮都存储一个命令对象，那么当按钮被按下的时候，就能够请命令对象作相关的工做。遥控器并不须要知道工做内容是什么，只要有个命令对象能喝正确的对象沟通，把事情作好就能够了。

　　分析7：使用这个模式，咱们可以建立一个API，将这些命令对象加载到按钮插槽，让遥控器的代码尽可能保持简单。而把家电自动化的工做和进行该工做的对象一块儿封装在命令对象中。

2、详细说明

　　命令模式：将请求封装成对象，这可让你使用不一样的请求、队列，或者日志请求来参数化其余对象。命令模式也能够支持撤销操做。

　　如今仔细看这个定义，咱们知道一个命令对象经过在特定接收者上绑定一组动做来封装一个请求。要达到这一点，命令对象将动做和接收者包进对象中。这个对象只暴露出一个execute()方法，当此方法被调用的时候，接收者就会进行这些动做。从外面来看，其余对象不知道究竟哪一个接收者进行了哪些动做，只知道若是调用execute()方法，请求的目的就能达到。

1.定义命令模式类图：

 

2.下面的类图提供了设计的全貌：

 

 

问：若是拥有了一个遥控器，却没法光凭按下一个按钮，就同时能弄暗灯光、打开音响和电视、设置好DVD，并让热水器开始加温，那么要这个遥控器还有什么意义？

答：此时就能够用到命令模式的延伸“宏命令”，制造一种新的命令，用来执行其余一堆命令。在宏命令中，用命令数组（集合）存储一大堆命令，当这个宏命令被遥控器执行时，就一次性执行数组里的每一个命令。（具体内容，可在代码列表查看）

 

问：接收者必定有必要存在吗？为什么命令对象不直接实现execute()方法的细节。

答：通常来讲，咱们尽可能设计“傻瓜”命令对象，它只懂得调用一个接收者的一个行为。然而，有许多“聪明”命令对象会实现许多逻辑，直接完成一个请求。固然你能够设计聪明的命令对象，只是这样一来，调用者和接收者之间的解耦程度是比不上“傻瓜”命令对象的，并且，你也不可以把接收者当作参数传给命令。

 

问：我能够建立PartyCommand，而后在它的execute()方法中调用其余的命令，利用这种作法实现Party模式（Party Mode）吗？

答：你能够这么作。而后，这等于把Party模式“硬编码”到PartyCommand中。为何要这么麻烦呢？利用宏命令，你能够动态地决定PartyCommand是由哪些命令组成，因此宏命令在使用上更灵活。通常来讲，宏命令的作法更优雅，也须要较少的新代码。

 

问：我如何可以实现多层次的撤销操做？换句话说，我但愿可以按下撤销按钮许屡次，撤销到很早很早之前的状态。

答：其实这至关容易作到，不要只记录最后一个被执行的命令，而使用一个堆栈记录操做过程的每个命令。而后，无论何时按下了撤销按钮，你均可以从堆栈中取出最上层的命令，而后调用它的Undo()方法。

 

3.命令模式的更多用途：

　　(1)队列请求：命令能够将运算块打包（一个接收者和一组动做），而后将它传来传去，就像是通常的对象同样。它甚至能够在不一样的线程中被调用。咱们能够利用这样的特性衍生一些应用，例如：日程安排、线程池、工做队列等。

想象有一个工做队列，你在某一端添加命令，而后另外一端则是线程，线程进行下面的动做，从队列中取出一个命令，调用它的Execute()方法，等待这个调用完成，而后将此命令对象丢弃，再取出下一个命令......

　　(2)日志请求：某些应用须要咱们将全部的动做都记录在日志中，并能在系统死机以后，从新调用这些动做恢复到以前的状态。经过新增两个方法（Store()、Load()），命令模式可以支持这一点。这种日志的方式对于遥控器来讲没有意义，然而，有许多调用大型数据结构的动做的应用，没法在每次改变发生时被快速地存储。经过使用记录日志，咱们能够将上次检查点以后的全部操做记录下来，若是系统出现情况，从检查点开始应用这些操做。

比方说，对于电子表格应用，咱们可能想要实现的错误恢复方式是将电子表格的操做记录在日志中，而不是每次电子表格一有变化就记录整个电子表格。对更高级的应用而言，这些技巧能够被扩展应用到事务处理中，也就是说，一整组操做必须完成后才算有效。

 

4.总结：

（1）当须要将发出请求的对象和执行请求的对象解耦的时候，使用命令模式

（2）在被解耦的二者之间是经过命令对象进行沟通的，命令对象封装了接收者和一个或一组动做。

（3）调用者经过调用命令对象的execute()发出请求，这会使得接收者的动做被调用。

（4）调用者能够接受命令当作参数，甚至在运行时动态地进行。

（5）命令能够支持撤销，作法是实现一个Undo()方法来回到execute()被执行前的状态。

（6）宏命令是命令的一种简单的延伸，容许调用多个命令，宏方法也能够支持撤销。

（7）命令也能够用来实现日志和事务系统。

3、代码列表

/// <summary>
/// 命令接口
/// </summary>
public interface ICommand
{
    /// <summary>
    /// 执行
    /// </summary>
    void Execute();
    /// <summary>
    /// 撤销
    /// </summary>
    void Undo();
}
public class RemoteControl
{
    private ICommand[] onCommands;
    private ICommand[] offCommands;
    private ICommand undoCommand;

    public RemoteControl()
    {
        onCommands = new ICommand[7];
        offCommands = new ICommand[7];
        ICommand noCommand = new NoCommand();
        for (int i = 0; i < 7; i++)
        {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
        undoCommand = noCommand;
    }

    public void SetCommand(int slot, ICommand onCommand, ICommand offCommand)
    {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }

    public void OnButtonWasPushed(int slot)
    {
        onCommands[slot].Execute();
        undoCommand = onCommands[slot];
    }

    public void OffButtonWasPushed(int slot)
    {
        offCommands[slot].Execute();
        undoCommand = offCommands[slot];
    }

    public void UndoButtonWasPushed()
    {
        undoCommand.Undo();
    }

    public override string ToString()
    {
        StringBuilder sb=new StringBuilder();
        sb.Append("\n---------Remote Control----------\n");
        for (int i = 0; i < onCommands.Length; i++)
        {
            sb.AppendFormat("[slot {0}] {1}    {2}",i,onCommands[i].GetType().FullName, offCommands[i].GetType().FullName);
            sb.AppendLine();
        }
        return sb.ToString();
    }
}
public class SimpleRemoteControl
{
    private ICommand slot;

    public void SetCommand(ICommand command)
    {
        slot = command;
    }

    public void ButtonWasPressed()
    {
        slot.Execute();
    }
}
//Worker
/// <summary>
/// 吊扇
/// </summary>
public class CeilLingFan
{
    public CeilLingFanSpeed speed { get; private set; } = 0;
    private string name;

    public CeilLingFan(string name)
    {
        this.name = name;
    }

    /// <summary>
    /// 高速
    /// </summary>
    public void High()
    {
        speed = CeilLingFanSpeed.High;
        Console.WriteLine("{0} ceilLingFan is highs", name);
    }
    /// <summary>
    /// 中速
    /// </summary>
    public void Medium()
    {
        speed = CeilLingFanSpeed.Medium;
        Console.WriteLine("{0} ceilLingFan is medium", name);
    }
    /// <summary>
    /// 低速
    /// </summary>
    public void Low()
    {
        speed = CeilLingFanSpeed.Low;
        Console.WriteLine("{0} ceilLingFan is low", name);
    }
    /// <summary>
    /// 关闭
    /// </summary>
    public void Off()
    {
        speed = CeilLingFanSpeed.Off;
        Console.WriteLine("{0} ceilLingFan is Off", name);
    }

    public enum CeilLingFanSpeed { High = 3, Medium = 2, Low = 1, Off = 0 }
}
/// <summary>
/// 车库门
/// </summary>
public class GarageDoor
{
    private string name;

    public GarageDoor(string name)
    {
        this.name = name;
    }

    /// <summary>
    /// 上升
    /// </summary>
    public void Up()
    {
        Console.WriteLine("{0} Garage door is open", name);
    }
    /// <summary>
    /// 降低
    /// </summary>
    public void Down()
    {
        Console.WriteLine("{0} Garage door is close", name);
    }
    /// <summary>
    /// 中止
    /// </summary>
    public void Stop()
    {
        Console.WriteLine("{0} Garage door is stop", name);
    }
    /// <summary>
    /// 灯光开启
    /// </summary>
    public void LightOn()
    {
        Console.WriteLine("{0} Garage Light is on", name);
    }
    /// <summary>
    /// 灯光关闭
    /// </summary>
    public void LightOff()
    {
        Console.WriteLine("{0} Garage Light is off", name);
    }
}
/// <summary>
/// 热浴盆
/// </summary>
public class Hottub
{
    /// <summary>
    /// 水循环
    /// </summary>
    public void Circulata()
    {
        Console.WriteLine("Tub water is circulata");
    }
    /// <summary>
    /// 喷射打开
    /// </summary>
    public void JetsOn()
    {
        Console.WriteLine("Jets is on");
    }
    /// <summary>
    /// 喷射关闭
    /// </summary>
    public void JetsOff()
    {
        Console.WriteLine("Jets is Off");
    }
    /// <summary>
    /// 设置温度
    /// </summary>
    public void SetTemperature()
    {
        Console.WriteLine("Default temperature is 46°C");
    }
}
/// <summary>
/// 灯光
/// </summary>
public class Light
{
    private string name;

    public Light(string name)
    {
        this.name = name;
    }

    /// <summary>
    /// 开启
    /// </summary>
    public void On()
    {
        Console.WriteLine("{0} light is On", name);
    }
    /// <summary>
    /// 关闭
    /// </summary>
    public void Off()
    {
        Console.WriteLine("{0} light is Off", name);
    }
}
/// <summary>
/// 立体声
/// </summary>
public class Stereo
{
    private string name;

    public Stereo(string name)
    {
        this.name = name;
    }

    /// <summary>
    /// 开启
    /// </summary>
    public void On()
    {
        Console.WriteLine("{0} Stereo is on", name);
    }
    /// <summary>
    /// 关闭
    /// </summary>
    public void Off()
    {
        Console.WriteLine("{0} Stereo is off", name);
    }
    /// <summary>
    /// 设置CD
    /// </summary>
    public void SetCd()
    {
        Console.WriteLine("Stereo Cd is on");
    }
    /// <summary>
    /// 设置DVD
    /// </summary>
    public void SetDvd()
    {
        Console.WriteLine("Stereo Dvd is on");
    }
    /// <summary>
    /// 设置收音机
    /// </summary>
    public void SetRadio()
    {
        Console.WriteLine("Stereo radio is on");
    }
    /// <summary>
    /// 设置音量
    /// </summary>
    public void SetVolume(byte volume)
    {
        Console.WriteLine("Stereo volume is {0}", volume);
    }
}
/// <summary>
/// 电视
/// </summary>
public class TV
{
    private string name;

    public TV(string name)
    {
        this.name = name;
    }

    /// <summary>
    /// 开启
    /// </summary>
    public void On()
    {
        Console.WriteLine("{0} TV is on", name);
    }
    /// <summary>
    /// 关闭
    /// </summary>
    public void Off()
    {
        Console.WriteLine("{0} TV is off", name);
    }
    /// <summary>
    /// 设置频道
    /// </summary>
    public void SetInputChannel()
    {
        Console.WriteLine("Defualt channel is CCTV1");
    }
    /// <summary>
    /// 设置音量
    /// </summary>
    public void SetVolume()
    {
        Console.WriteLine("Defualt volume is 5");
    }
}
//Commands
/// <summary>
/// 吊扇基础命令类
/// </summary>
public abstract class CeilingFanCommand : ICommand
{
    protected CeilLingFan ceilLingFan;
    private CeilLingFan.CeilLingFanSpeed speed;

    public void Execute()
    {
        speed = ceilLingFan.speed;
        FanExecute();
    }

    public abstract void FanExecute();

    public void Undo()
    {
        switch (speed)
        {
            case CeilLingFan.CeilLingFanSpeed.High:
                ceilLingFan.High();
                break;
            case CeilLingFan.CeilLingFanSpeed.Medium:
                ceilLingFan.Medium();
                break;
            case CeilLingFan.CeilLingFanSpeed.Low:
                ceilLingFan.Low();
                break;
            case CeilLingFan.CeilLingFanSpeed.Off:
                ceilLingFan.Off();
                break;
        }
    }
}
public class CeilLingFanHighCommand : CeilingFanCommand
{
    public CeilLingFanHighCommand(CeilLingFan ceilLingFan)
    {
        base.ceilLingFan = ceilLingFan;
    }

    public override void FanExecute()
    {
        ceilLingFan.High();
    }
}
public class CeilLingFanLowCommand : CeilingFanCommand
{
    public CeilLingFanLowCommand(CeilLingFan ceilLingFan)
    {
        base.ceilLingFan = ceilLingFan;
    }

    public override void FanExecute()
    {
        ceilLingFan.Low();
    }
}
public class CeilLingFanMediumCommand : CeilingFanCommand
{
    public CeilLingFanMediumCommand(CeilLingFan ceilLingFan)
    {
        base.ceilLingFan = ceilLingFan;
    }

    public override void FanExecute()
    {
        ceilLingFan.Medium();
    }
}
public class CeilLingFanOffCommand : CeilingFanCommand
{
    public CeilLingFanOffCommand(CeilLingFan ceilLingFan)
    {
        base.ceilLingFan = ceilLingFan;
    }

    public override void FanExecute()
    {
        ceilLingFan.Off();
    }
}
public class GarageDoorCloseCommand : ICommand
{
    private GarageDoor garageDoor;

    public GarageDoorCloseCommand(GarageDoor garageDoor)
    {
        this.garageDoor = garageDoor;
    }

    public void Execute()
    {
        garageDoor.Down();
        garageDoor.LightOff();
    }

    public void Undo()
    {
        garageDoor.LightOn();
        garageDoor.Up();
    }
}
public class GarageDoorOpenCommand : ICommand
{
    private GarageDoor garageDoor;

    public GarageDoorOpenCommand(GarageDoor garageDoor)
    {
        this.garageDoor = garageDoor;
    }

    public void Execute()
    {
        garageDoor.Up();
        garageDoor.LightOn();
    }

    public void Undo()
    {
        garageDoor.Down();
        garageDoor.LightOff();
    }
}
public class HottubOffCommand:ICommand
{
    private Hottub hottub;

    public HottubOffCommand(Hottub hottub)
    {
        this.hottub = hottub;
    }

    public void Execute()
    {
        hottub.JetsOff();
    }

    public void Undo()
    {
        hottub.JetsOn();
    }
}
public class HottubOnCommand : ICommand
{
    private Hottub hottub;

    public HottubOnCommand(Hottub hottub)
    {
        this.hottub = hottub;
    }

    public void Execute()
    {
        hottub.JetsOn();
        hottub.SetTemperature();
    }

    public void Undo()
    {
        hottub.JetsOff();
    }
}
public class LightOffCommand:ICommand
{
    private Light light;

    public LightOffCommand(Light light)
    {
        this.light = light;
    }

    public void Execute()
    {
        light.Off();
    }

    public void Undo()
    {
        light.On();
    }
}
public class LightOnCommand : ICommand
{
    private Light light;

    public LightOnCommand(Light light)
    {
        this.light = light;
    }

    public void Execute()
    {
        light.On();
    }

    public void Undo()
    {
        light.Off();
    }
}
/// <summary>
/// 更多命令（宏命令）
/// </summary>
public class MacroCommand:ICommand
{
    private ICommand[] commands;

    public MacroCommand(ICommand[] commands)
    {
        this.commands = commands;
    }

    public void Execute()
    {
        foreach (ICommand command in commands)
        {
            command.Execute();
        }
    }

    public void Undo()
    {
        foreach (ICommand command in commands)
        {
            command.Undo();
        }
    }
}
/// <summary>
/// 没有命令
/// </summary>
public class NoCommand : ICommand
{
    public void Execute()
    {

    }

    public void Undo()
    {

    }
}
public class StereoOffCommand : ICommand
{
    private Stereo stereo;

    public StereoOffCommand(Stereo stereo)
    {
        this.stereo = stereo;
    }

    public void Execute()
    {
        stereo.Off();
    }

    public void Undo()
    {
        stereo.On();
    }
}
public class StereoOnCommand : ICommand
{
    private Stereo stereo;

    public StereoOnCommand(Stereo stereo)
    {
        this.stereo = stereo;
    }

    public void Execute()
    {
        stereo.On();
    }

    public void Undo()
    {
        stereo.Off();
    }
}
public class StereoOnWithCDCommand:ICommand
{
    private Stereo stereo;

    public StereoOnWithCDCommand(Stereo stereo)
    {
        this.stereo = stereo;
    }

    public void Execute()
    {
        stereo.On();
        stereo.SetCd();
        stereo.SetVolume(11);
    }

    public void Undo()
    {
        stereo.Off();
    }
}
public class TVOffCommand:ICommand
{
    private TV tv;

    public TVOffCommand(TV tv)
    {
        this.tv = tv;
    }

    public void Execute()
    {
        tv.Off();
    }

    public void Undo()
    {
        tv.On();
    }
}
public class TVOnCommand : ICommand
{
    private TV tv;

    public TVOnCommand(TV tv)
    {
        this.tv = tv;
    }

    public void Execute()
    {
        tv.On();
        tv.SetInputChannel();
        tv.SetVolume();
    }

    public void Undo()
    {
        tv.Off();
    }
}
//RunTest
[Test]
public void RemoteLoader()
{
    //单个插槽的简单控制装置
    /*SimpleRemoteControl remote = new SimpleRemoteControl();
    Light light = new Light();
    GarageDoor garageDoor = new GarageDoor();
    LightOnCommand lightOn = new LightOnCommand(light);
    GarageDoorOpenCommand garageOpen = new GarageDoorOpenCommand(garageDoor);
    remote.SetCommand(lightOn);
    remote.ButtonWasPressed();
    remote.SetCommand(garageOpen);
    remote.ButtonWasPressed();*/

    //多个插槽(含有关闭功能)的控制装置
    /*RemoteControl remoteControl = new RemoteControl();
    Light livingRoomLight = new Light("Living Room");
    Light kitchenLight = new Light("Kitchen");
    CeilLingFan ceilLingFan = new CeilLingFan("Living Room");
    GarageDoor garageDoor = new GarageDoor("");
    Stereo stereo = new Stereo("Living Room");

    LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
    LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
    LightOnCommand kitchenLightOn = new LightOnCommand(kitchenLight);
    LightOffCommand kitchenLightOff = new LightOffCommand(kitchenLight);
    CeilLingFanLowCommand ceilingFanLow = new CeilLingFanLowCommand(ceilLingFan);
    CeilLingFanOffCommand ceilLingFanOff = new CeilLingFanOffCommand(ceilLingFan);
    GarageDoorOpenCommand garageDoorOpen = new GarageDoorOpenCommand(garageDoor);
    GarageDoorCloseCommand garageDoorClose = new GarageDoorCloseCommand(garageDoor);
    StereoOnWithCDCommand stereoOnWithCd = new StereoOnWithCDCommand(stereo);
    StereoOffCommand stereoOff = new StereoOffCommand(stereo);

    remoteControl.SetCommand(0, livingRoomLightOn, livingRoomLightOff);
    remoteControl.SetCommand(1, kitchenLightOn, kitchenLightOff);
    remoteControl.SetCommand(2, ceilingFanLow, ceilLingFanOff);
    remoteControl.SetCommand(3, garageDoorOpen, garageDoorClose);
    remoteControl.SetCommand(4, stereoOnWithCd, stereoOff);

    Console.WriteLine(remoteControl);

    remoteControl.OnButtonWasPushed(0);
    remoteControl.OffButtonWasPushed(0);
    remoteControl.OnButtonWasPushed(1);
    remoteControl.OffButtonWasPushed(1);
    remoteControl.OnButtonWasPushed(2);
    remoteControl.OffButtonWasPushed(2);
    remoteControl.OnButtonWasPushed(3);
    remoteControl.OffButtonWasPushed(3);
    remoteControl.OnButtonWasPushed(4);
    remoteControl.OffButtonWasPushed(4);*/

    //多个插槽(含有关闭功能,含有撤销功能)的控制装置
    /*RemoteControl remoteControl = new RemoteControl();
    Light livingRoomLight = new Light("Living Room");
    LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
    LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
    remoteControl.SetCommand(0, livingRoomLightOn, livingRoomLightOff);

    remoteControl.OnButtonWasPushed(0);
    remoteControl.OffButtonWasPushed(0);
    Console.WriteLine(remoteControl);
    remoteControl.UndoButtonWasPushed();
    remoteControl.OffButtonWasPushed(0);
    remoteControl.OnButtonWasPushed(0);
    Console.WriteLine(remoteControl);
    remoteControl.UndoButtonWasPushed();*/

    //多个插槽(含有状态对象的撤销功能)的控制装置
    /*RemoteControl remoteControl = new RemoteControl();
    CeilLingFan ceilLingFan = new CeilLingFan("Living Room");
    CeilLingFanHighCommand ceilingFanHigh = new CeilLingFanHighCommand(ceilLingFan);
    CeilLingFanMediumCommand ceilLingFanMedium = new CeilLingFanMediumCommand(ceilLingFan);
    CeilLingFanOffCommand ceilLingFanOff = new CeilLingFanOffCommand(ceilLingFan);

    remoteControl.SetCommand(0, ceilLingFanMedium, ceilLingFanOff);
    remoteControl.SetCommand(1, ceilingFanHigh, ceilLingFanOff);

    remoteControl.OnButtonWasPushed(0);
    remoteControl.OffButtonWasPushed(0);
    Console.WriteLine(remoteControl);
    remoteControl.UndoButtonWasPushed();

    remoteControl.OnButtonWasPushed(1);
    Console.WriteLine(remoteControl);
    remoteControl.UndoButtonWasPushed();*/

    //多个插槽(含有宏命令)的控制装置
    RemoteControl remoteControl = new RemoteControl();
    Light light = new Light("Living Room");
    TV tv = new TV("Living Room");
    Stereo stereo = new Stereo("Living Room");
    Hottub hottub = new Hottub();

    LightOnCommand lightOn = new LightOnCommand(light);
    StereoOnCommand stereoOn = new StereoOnCommand(stereo);
    TVOnCommand tvOn = new TVOnCommand(tv);
    HottubOnCommand hottubOn = new HottubOnCommand(hottub);

    LightOffCommand lightOff = new LightOffCommand(light);
    StereoOffCommand stereoOff = new StereoOffCommand(stereo);
    TVOffCommand tvOff = new TVOffCommand(tv);
    HottubOffCommand hottubOff = new HottubOffCommand(hottub);

    ICommand[] partyOn = { lightOn, stereoOn, tvOn, hottubOn };
    ICommand[] partyOff = { lightOff, stereoOff, tvOff, hottubOff };
    MacroCommand partyOnMacro = new MacroCommand(partyOn);
    MacroCommand partyOffMacro = new MacroCommand(partyOff);
    remoteControl.SetCommand(0, partyOnMacro, partyOffMacro);

    Console.WriteLine(remoteControl);
    Console.WriteLine("-----Pushing Macro On-----");
    remoteControl.OnButtonWasPushed(0);
    Console.WriteLine("=====Pushing Macro Off----");
    remoteControl.OffButtonWasPushed(0);
}

View Code

---------------------------------以上内容根据《head frist design mode》进行整理