设计模式 - 战略模式

Question

我是设计模式的初学者.

假设我正在开发一个C#应用程序来跟踪开发团队中各个成员(即项目跟踪器)执行的开发工作.

我试图受到战略模式的启发.

所以我正在设计我的类和接口,如下所示:

interface IEmployee
{
    void Retires();
    void TakesLeave();
}

interface IResponsible
{
void AcknowledgeJobAccomplish();
void CompletesJob();
}

interface ILeader
{
    void FormsTeam();
    void RecruitsNewMember();
    void KicksOutMemberFromTheTeam();
    void AssignsJob();
void UnassignsJob();
void QueriesTheJobStatus();
void ChangesTheJobStatus();
}

interface IPersistent
{
    void Save();
    void Update();
    void Delete();  
}

abstract class TeamMember : IEmployee, IResponsible, IPersistent
{
    string Name;
}

class Programmer : TeamMember
{
}

class LeadProgrammer : Programmer, ILeader
{
    ProgrammerCollection associateProgrammers;
}

class ProjectManager :  TeamMember, ILeader
{
    TeamMemberCollection teamMembers;
}

abstract class Tester : TeamMember
{
}

class UnitTester : Tester
{
}

class QC : Tester
{
}

class SupportStaff : TeamMember
{
}

我应该做些什么来改进这个设计？

Answer 1

好吧,首先,你所拥有的不是战略模式的实例.该策略模式允许对做事情的方法的动态规范.你在这里拥有的不仅仅是标准的界面设计,你可以通过界面继承来分配职责和能力.

编辑:我们来举个例子.假设你有一群工人; 你还有一套任务.每个工作人员都可以执行任务.这些任务可以包含多个内容,例如DoFoo()和DoBar().每个工人都不知道他们将执行什么任务; 他们只是知道他们什么时候出现他们会做任务.

因此,我们希望将Workers建模为具有将执行的任务.由于任务变化很大,我们将实现Task作为接口.

所以我们将:

public class Worker 
{
   public Task myTask;

   public Worker(Task task)
   {
      myTask = task;
   }

   public void DoWork() 
      {
      myTask.DoTask();
      }
   }
}

Interface Task
{
   void DoTask();
}

public class Task1 : Task
{
   public void DoTask()
   {
   // Do whatever Task1 will do
   }
}

public class Task2 : Task
{
   public void DoTask()
   {
   // Do whatever Task2 will do
   }
}

public class Job
{
   public List<Worker> workers;

   public void Job()
   {
      workers.Add(new Worker(new Task1()));
      workers.Add(new Worker(new Task2()));
   }

   public void DoJob()
   {
      foreach (Worker worker in workers)
      {
      worker.DoWork();
      }
   }

   public void ChangeJobsToTask1()
   {
      foreach (Worker worker in workers)
      {
         worker.myTask = new Task1();
      }
   }

   public void ChangeJobsToTask2()
   {
      foreach (Worker worker in workers)
      {
         worker.myTask = new Task2();
      }
   }
}

那么当我们实例化a时Job,Job会产生两个Workers.第一个Worker有Task1任务; 第二个Worker有Task2任务.为了使Workers做他们的Tasks,我们DoJob()在Job类上调用DoWork()方法,该方法只调用每个Workers 上的方法,然后在DoTask()每个Tasks 上调用方法Worker.

如果我们想要将Workers 更改为all do Task1,我们调用ChangeJobsToTask1()方法,该方法为包含的所有对象设置Taskto ; 如果,在那时,我们调用on 对象,所有s将执行任务.同样,如果我们想要将s 更改为,只需调用方法; 然后所有的s将在调用它们的方法时执行.Task1WorkerJobDoJob()JobWorkerTask1TaskTask2ChangeJobsToTask2()WorkerTask2.DoTask()DoWork()

这里抽象的重点是Workers暴露了一种DoWork()方法,但它们并不一定知道正在做什么工作.也就是说,Tasks的Workers是可以互换的; 在Worker的只有我知道他们会做Task的,但它是什么的细节是不重要的Worker秒.