我是设计模式的初学者。

假设我正在开发一个 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 
{ 
} 

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

请您参考如下方法:

好吧，首先，您所拥有的不是策略模式的实例。 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。