代码实现

/*
 * 行为实现者
*/
namespace DesignPattern.Command
{
    public class Application
    {
        public void OpenDocument()
        {
        }
    }
}

/*
 * 行为实现者
*/
namespace DesignPattern.Command
{
    public class Document
    {
        string path;
        public Document(string docPath)
        {
            path = docPath;
        }

        public void Copy()
        {
        }

        public void Cut()
        {
        }

        public void Paste()
        {
        }
    }
}

/*
 * 行为对象
*/
namespace DesignPattern.Command
{
    // 定义行为接口
    public interface ICommand
    {
        void Execute();
    }

    // 打开文档
    public class OpenCommand : ICommand
    {
        // 使用应用程序打开文档
        Application app;

        public OpenCommand(Application application)
        {
            app = application;
        }

        public void Execute()
        {
            app.OpenDocument();
        }
    }

    public class CopyCommand : ICommand
    {
        Document doc;

        public CopyCommand(Document document)
        {
            doc = document;
        }

        public void Execute()
        {
            doc.Copy();
        }
    }

    public class CutCommand : ICommand
    {
        Document doc;

        public CutCommand(Document document)
        {
            doc = document;
        }

        public void Execute()
        {
            doc.Cut();
        }
    }

    public class PasteCommand : ICommand
    {
        Document doc;

        public PasteCommand(Document document)
        {
            doc = document;
        }

        public void Execute()
        {
            doc.Paste();
        }
    }
}

/*
 * 行为请求者
*/
namespace DesignPattern.Command
{
    public class Client
    {
        public void DealDocument()
        {
            Document doc = new Document("DocumentPath");
            Command command = new CopyCommand(doc);
            command .Execute();
        }
    }
}

要点：
      1、本模式的基本目的在于将行为请求者和实现者解耦，常见的实现方法是将行为抽象为对象。
      2、实现行为的具体对象有时候根据需要可能会保存一些额外的状态信息，比如实现撤销、重做时。
      3、可以和Composite模式结合，实现多个命令的组合成复杂命令。
      4、本模式和Delegate有些类似。但两者定义行为接口的规范有所区别：本模式以面向对象中“接口-实现”来定义行为接口规范，更严格，更符合抽象原语；Delegate以函数签名来定义行为接口规范，更灵活，但抽象能力比较弱。