新的一年的春天到啦,又是一轮跳槽离职的高峰期,面对新的一年的开始大家都希望各个方面都在更上一层楼,难免会出现跳槽、离职创业等等现象,最近项目组有人离职啦,当然人走了活还是要有人干的嘛,如何合理的利用有限的人力资源把多余的活分配出去呢?这就是项目经理们考虑的事情啦!不过一般还是会出现一个开发人员同时兼有几个项目的现象啦~!OK,这个就是今天的场景,我们来用代码模拟一下吧!

        1.场景模拟

        首先我们考虑,当项目多,人手不够时,我们需要一个人去同时兼有好几个项目的工作,可能有开发也可能有运维!

        那么第一步我们先设计一个项目类,分别代表需要参与的项目,代码如下:

  1. /// <summary>  
  2.   /// Web项目类  
  3.   /// </summary>  
  4.   public class WebProject  
  5.   {  
  6.       /// <summary>  
  7.       /// 项目名称  
  8.       /// </summary>  
  9.       public string ProjectName { getset; }  
  10.   }  
           接下来第二步,我们设计一个开发者类表示具体的开发人员,并且开发人员具有开发项目和运维项目的操作,代码如下:
  1. /// <summary>  
  2.  /// 开发者  
  3.  /// </summary>  
  4.  public class Developer  
  5.  {  
  6.      /// <summary>  
  7.      /// 开发项目  
  8.      /// </summary>  
  9.      /// <param name="project">项目</param>  
  10.      public void Coding(WebProject project)  
  11.      {  
  12.          Console.WriteLine("开发{0}项目",project.ProjectName);  
  13.      }  
  14.  
  15.      /// <summary>  
  16.      /// 运维项目  
  17.      /// </summary>  
  18.      /// <param name="project">项目</param>  
  19.      public void UpdateRoutine(WebProject project)  
  20.      {  
  21.          Console.WriteLine("维护{0}项目", project.ProjectName);  
  22.      }  
  23.  }  
         主函数调用方法如下:
  1. static void Main(string[] args)  
  2.   {  
  3.           //表示一个具体的项目名字叫:项目A  
  4.           WebProject wpA = new WebProject() { ProjectName = "项目A" };  
  5.           //表示一个具体的项目名字叫:项目B  
  6.           WebProject wpB = new WebProject() { ProjectName = "项目B" };  
  7.  
  8.           //实例化一个开发者,程序员  
  9.           Developer dp = new Developer();  
  10.  
  11.           //命令他开发项目A  
  12.           dp.Coding(wpA);  
  13.           //命令他开发项目B  
  14.           dp.UpdateRoutine(wpB);  
  15.   }  
          这么简单的程序运行结果我就不贴出来啦,我们来看看上边的代码,我们把主函数的调用当做客户,我们发现如果客户直接和开发者形成这种紧耦合的状态是非常不好的,比如说,客户会提出很多业务上的要求,而开发者并不能很准确的估算出开发成本与时间,所以我们需要一个项目经理来与客户沟通,并且将客户提出的不合理需求过滤掉,在给开发人员发出一个命令将项目交给开发人员!也就是说需要将“命令发起者”与“命令实现者”分离!

        2.命令模式

         那么我们来看看实现“命令发起者”与“命令实现者”分离的设计模式,命令模式:

         命令模式:将一个请求封装为一个对象,从而可用不同的的请求对客户进行参数化,队请求排队或者记录请求日志,以及支持可撤销的操作。

         命令模式结构图如下:

     

       ①接口ICommand:用来声明抽象一个命令操作的接口。

       ②ConcreteCommand:具体的命令实现,用来表示命令的类型例如上边场景中的开发项目和维护项目可分别实现为:开发项目命令,维护项目命令等。

       ③Receiver:具体命令的实现者,也就是说命令的执行者,相对于上边场景中的开发者。

       ④Invoker:命令的指挥者,用来设置命令,并且通知执行命令,相对于上边场景中的项目经理。

       了解完命令模式的概念后,我们用命令模式来实现上边的场景:

        首先是命令接口ICommand的实现,代码如下:

  1. public interface ICommand  
  2.   {  
  3.       void Excute(WebProject project);  
  4.   }  
          接下来就是我们接受命令并且执行的实现者啦,也就是我们场景中的开发者,代码如下:
  1. /// <summary>  
  2.     /// 开发者  
  3.     /// </summary>  
  4.     public class Developer  
  5.     {  
  6.         /// <summary>  
  7.         /// 开发项目  
  8.         /// </summary>  
  9.         /// <param name="project">项目</param>  
  10.         public void Coding(WebProject project)  
  11.         {  
  12.             Console.WriteLine("开发{0}项目", project.ProjectName);  
  13.         }  
  14.  
  15.         /// <summary>  
  16.         /// 运维项目  
  17.         /// </summary>  
  18.         /// <param name="project">项目</param>  
  19.         public void UpdateRoutine(WebProject project)  
  20.         {  
  21.             Console.WriteLine("维护{0}项目", project.ProjectName);  
  22.         }  
  23.     }  
           现在有了命令的实现者,就应该有具体的命令啦,上边那场景中的命令分别有,开发命令与维护命令,具体代码如下:
  1. /// <summary>  
  2.    /// 开发项目命令  
  3.    /// </summary>  
  4.    public class CodingCommand : ICommand  
  5.    {  
  6.        Developer dp { getset; }  
  7.        public WebProject project { getset; }//所对应的项目  
  8.  
  9.        public void Excute()  
  10.        {  
  11.            dp.Coding(project);  
  12.        }  
  13.    }  
  14.  
  15.    /// <summary>  
  16.    /// 维护项目命令  
  17.    /// </summary>  
  18.    public class UpdateRoutineCommand : ICommand  
  19.    {  
  20.        Developer dp { getset; }  
  21.        public WebProject project { getset; }//所对应的项目  
  22.  
  23.        public void Excute()  
  24.        {  
  25.            dp.UpdateRoutine(project);  
  26.        }  
  27.    }  
        命令与实现者都就绪了,指挥调度者就该出现了,也就是项目经理,项目经理用来负责设置命令调度命令执行,代码如下:
  1. /// <summary>  
  2.   /// 项目经理类  
  3.   /// </summary>  
  4.   public class ProjectManager  
  5.   {  
  6.       List<ICommand> cmdList = new List<ICommand>();  
  7.  
  8.       /// <summary>  
  9.       /// 设置命令  
  10.       /// </summary>  
  11.       /// <param name="cmd"></param>  
  12.       public void SetCommand(ICommand cmd)  
  13.       {  
  14.           cmdList.Add(cmd);  
  15.       }  
  16.  
  17.       /// <summary>  
  18.       /// 发起命令  
  19.       /// </summary>  
  20.       public void ExcuteCommand()  
  21.       {  
  22.           cmdList.ForEach(p => p.Excute());  
  23.       }  
  24.   }  
         代码写好后,我们来模拟一下调用吧,现在项目经理需要分配给开发者两个任务,一个是开发项目A,另一个是维护项目B!主函数调用如下:
  1.    //表示一个具体的项目名字叫:项目A  
  2.             WebProject wpA = new WebProject() { ProjectName = "项目A" };  
  3.             //表示一个具体的项目名字叫:项目B  
  4.             WebProject wpB = new WebProject() { ProjectName = "项目B" };  
  5.             //开发者  
  6.             Developer developer= new Developer();  
  7.  
  8.             //开发者所需要接收的命令  
  9.             ICommand codeCmd = new CodingCommand() { project = wpA, dp = developer };  
  10.             ICommand UpdateCmd = new UpdateRoutineCommand() { project = wpB, dp = developer };  
  11.  
  12.             //项目经理  
  13.             ProjectManager pm = new ProjectManager();  
  14.             //设置命令  
  15.             pm.SetCommand(codeCmd);  
  16.             pm.SetCommand(UpdateCmd);  
  17.             //发起命令让开发者去完成  
  18.             pm.ExcuteCommand();  
  19. }  
                那么一个简单的命令模式就完成了。

      3.更加灵活的分配任务

       接下来我们在增加一些要求:

       ①项目经理每次发起的命令都需要记录下来,年底好根据开发者的工作量评估奖金。

       ②项目经理可以撤销发起的命令,例如:撤销维护项目B的命令,让开发者专心做项目A的开发工作。

       回顾下命令模式的定义,上边两条需求就等同于定义中的“队请求排队或者记录请求日志,以及支持可撤销的操作

       那么我们给需求中加入一个方法用来撤销命令,因为项目经理类中已经有一个集合来记录命令的总数了,所以已经实现了请求记录的功能啦,我们只需加入撤销功能就好了。

       首先,给ICommand接口加入一个Cancel方法,用来表示撤销操作,因为命令撤销了需要通知实现者做一些撤销的工作,代码如下:

  1. public interface ICommand  
  2.    {  
  3.        void Excute();  
  4.        void Cancel();  
  5.    }  
         接下来既然有取消了,那么开发者受到取消命令后要执行一些关于取消的代码,所以开发者类加入一个方法StopCoding,表示停止项目的工作,代码如下:
  1. /// <summary>  
  2.     /// 开发者  
  3.     /// </summary>  
  4.     public class Developer  
  5.     {  
  6.         /// <summary>  
  7.         /// 开发项目  
  8.         /// </summary>  
  9.         /// <param name="project">项目</param>  
  10.         public void Coding(WebProject project)  
  11.         {  
  12.             Console.WriteLine("开发{0}项目", project.ProjectName);  
  13.         }  
  14.  
  15.         /// <summary>  
  16.         /// 运维项目  
  17.         /// </summary>  
  18.         /// <param name="project">项目</param>  
  19.         public void UpdateRoutine(WebProject project)  
  20.         {  
  21.             Console.WriteLine("维护{0}项目", project.ProjectName);  
  22.         }  
  23.  
  24.         /// <summary>  
  25.         /// 停止项目的工作  
  26.         /// </summary>  
  27.         /// <param name="project"></param>  
  28.         public void StopCoding(WebProject project)  
  29.         {  
  30.             Console.WriteLine("停止{0}项目",project.ProjectName);  
  31.         }  
  32.     }  
        修改实际的命令类实现撤销命令的方法,并调用开发者类的StopCoding方法做撤销命令的工作,代码如下:
  1. /// <summary>  
  2.     /// 开发项目命令  
  3.     /// </summary>  
  4.     public class CodingCommand : ICommand  
  5.     {  
  6.         public Developer dp { getset; }  
  7.         public WebProject project { getset; }//所对应的项目  
  8.  
  9.         public void Excute()  
  10.         {  
  11.             dp.Coding(project);  
  12.         }  
  13.  
  14.         /// <summary>  
  15.         /// 撤销操作  
  16.         /// </summary>  
  17.         public void Cancel()  
  18.         {  
  19.             dp.StopCoding(project);  
  20.         }  
  21.     }  
  22.  
  23.     /// <summary>  
  24.     /// 维护项目命令  
  25.     /// </summary>  
  26.     public class UpdateRoutineCommand : ICommand  
  27.     {  
  28.         public Developer dp { getset; }  
  29.         public WebProject project { getset; }//所对应的项目  
  30.  
  31.         public void Excute()  
  32.         {  
  33.             dp.UpdateRoutine(project);  
  34.         }  
  35.  
  36.         /// <summary>  
  37.         /// 撤销操作  
  38.         /// </summary>  
  39.         public void Cancel()  
  40.         {  
  41.             dp.StopCoding(project);  
  42.         }  
  43.     }  
       接下来就是命令的指挥者啦,项目经理首先设置一个撤销命令,并且将执撤销命令,在执行撤销命令的时候首先要将命令从集合中移除,因为该开发者已经不参与该撤销项目的工作了,所以不记录考核依据中,在调用命令中的撤销方法让开发者做具体的撤销工作。代码如下:
  1. /// <summary>  
  2.     /// 项目经理类  
  3.     /// </summary>  
  4.     public class ProjectManager  
  5.     {  
  6.         List<ICommand> cmdList = new List<ICommand>();  
  7.  
  8.         /// <summary>  
  9.         /// 设置命令  
  10.         /// </summary>  
  11.         /// <param name="cmd"></param>  
  12.         public void SetCommand(ICommand cmd)  
  13.         {  
  14.             cmdList.Add(cmd);  
  15.         }  
  16.  
  17.         /// <summary>  
  18.         /// 发起命令  
  19.         /// </summary>  
  20.         public void ExcuteCommand()  
  21.         {  
  22.             cmdList.ForEach(p => p.Excute());  
  23.         }  
  24.  
  25.         /// <summary>  
  26.         /// 返回记录行数  
  27.         /// </summary>  
  28.         /// <returns></returns>  
  29.         public int GetCommandCount()  
  30.         {  
  31.             return cmdList.Count;  
  32.         }  
  33.  
  34.         /// <summary>  
  35.         /// 撤销命令  
  36.         /// </summary>  
  37.         /// <param name="cmd"></param>  
  38.         public void CancelExectueCommand(ICommand cmd)  
  39.         {  
  40.             cmd.Cancel();  
  41.             cmdList.Remove(cmd);  
  42.         }  
  43.     }  
     可见对功能的封装和“请求与实现分离”,可以让我们很容易的进行撤销与记录的工作,可以再命令执行前作一些必须要的操作。主函数调用如下:
  1. static void Main(string[] args)  
  2.        {  
  3.            //表示一个具体的项目名字叫:项目A  
  4.            WebProject wpA = new WebProject() { ProjectName = "项目A" };  
  5.            //表示一个具体的项目名字叫:项目B  
  6.            WebProject wpB = new WebProject() { ProjectName = "项目B" };  
  7.            //开发者  
  8.            Developer developer= new Developer();  
  9.  
  10.            //开发者所需要接收的命令  
  11.            ICommand codeCmd = new CodingCommand() { project = wpA, dp = developer };  
  12.            ICommand UpdateCmd = new UpdateRoutineCommand() { project = wpB, dp = developer };  
  13.  
  14.            //项目经理  
  15.            ProjectManager pm = new ProjectManager();  
  16.            //设置命令  
  17.            pm.SetCommand(codeCmd);  
  18.            pm.SetCommand(UpdateCmd);  
  19.            //发起命令让开发者去完成  
  20.            pm.ExcuteCommand();  
  21.  
  22.            pm.CancelExectueCommand(UpdateCmd);//撤销UpdateCmd命令  
  23.         }  
              命令模式总结:

       ①它能很容易的维护所有命令的集合。

       ②它可以很方便的实现撤销和恢复命令。

       ③可以很方便的将每个执行记录日志。

       ④最重要的就是将发起者与实现者分离。