design-patterns - 设计模式 - 策略模式

Question

我是设计模式的初学者。

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

我试图从战略模式中获得灵感。

所以我正在设计我的类和接口(interface)如下:

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

好吧，首先，您所拥有的不是策略模式的实例。 Strategy Pattern允许对完成工作的方法进行动态规范。您在这里所拥有的实际上更像是一个标准的接口(interface)设计，您可以通过接口(interface)继承来分配职责和能力。

编辑:让我们举个例子。假设您有一组 worker ；您还有一组任务。每个 Worker 可以执行一个任务。这些任务可以包含多个内容，例如 DoFoo() 和 DoBar()。每个 Worker 都不知道他们将执行什么任务；他们只知道当他们出现时他们将执行一项任务。

因此，我们希望将 Workers 建模为他们将执行的任务。由于任务变化很大，我们将任务实现为接口(interface)。

所以我们会有:

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();
      }
   }
}

那么当我们实例化一个 Job 时会发生什么？ , Job创建两个 Worker s。第一个 Worker有一个 Task1任务;第二个 Worker有一个 Task2任务。制作 Worker做他们的 Task s，我们称之为 DoJob() Job 上的方法类，它只调用 DoWork()每个 Worker 上的方法s，然后调用 DoTask()每个 Task 上的方法s 那 Worker s 被设置为。

如果我们要更改 Worker所有人都要做 Task1 ，我们称之为 ChangeJobsToTask1()方法，它设置 Task至 Task1对于所有 Worker Job 包含的对象;如果那时我们调用 DoJob()在 Job对象，所有 Worker s 将执行 Task1任务。同样，如果我们要更改 Task转至 Task2 ，只需调用 ChangeJobsToTask2()方法;所有 Worker然后 s 将执行 Task2.DoTask()当他们的 DoWork()方法被调用。

这里抽象的重点是 Worker s 公开一个 DoWork()方法，但他们不一定知道正在完成的工作是什么。也就是说， Task s 为 Worker s 是可以互换的； Worker s 只知道他们要做 Task ，但它的细节对于 Worker 来说并不重要。 s。