实施战略模式，而不是几个if语句

本文关键字：几个 语句 if 模式 施战略 | 更新日期: 2023-09-27 18:28:13

我有很多if statements的方法，其中我根据员工职位筛选SharePoint list。结果是作为参数传递给另一个方法CCD_ 4的CCD_。

 public List<Phone> GetListOfPhones(Employee emp)
 {
    List<Phone> records = new List<Phone>();
    string query = string.Empty;
    if (emp.Positions.Count == 1 && emp.Positions[0] == "Regular")
    {
       query = "";// some querystring                              
    }

    if (emp.Positions.Count == 1 && emp.Positions[0] == "OfficeDirector")
    {   
       query = "";// some querystring    
    }
    if (emp.Positions.Count == 1 && emp.Positions[0] == "Admin")
    {
        query = "";// some querystring 
    }              
    if (emp.Positions.Count == 2 && emp.Positions.Contains("Regular") && emp.Positions.Contains("OfficeDirector"))
    {
      query = "";// some querystring 
     }
   var rawItems = QuerySPList(query);
   foreach (SPListItem item in rawItems)
   {
        //business logic 
   }
   return records;
}}

我已经读到，通过实现strategy pattern，我们可以避免使用大量if的混乱代码，然而，我对开发和设计模式是新手，所以我在这方面几乎不需要帮助，所以如果有人能指导我应该做什么并给我建议，请随时回答我的问题。我有主意，但我认为我走错了方向。想法是创建interface IRoleHandler，然后将其实现为3 classes，例如RoleAdmin ,RoleRegular,RoleOfficeDirector

public interface IRoleHandler<T>
{
    string handleRole(T obj);
}
public class RoleAdmin:IRoleHandler<Employee>
{
    public string handleRole(Employee emp)
    {
        if (emp.Positions.Count == 1 && emp.Positions[0] == "Admin")
        {
            //return some string query
        }
    }
}

然后想法是创建dictionary，类似于这样的东西：

Dictionary<string, IRoleHandler<Employee>> strategyHandlers = new Dictionary<string, IRoleHandler<Employee>>();
        strategyHandlers.Add("Admin", new RoleAdmin());
        strategyHandlers.Add("Regular", new RoleRegularUser());

实施战略模式，而不是几个if语句

首先，我认为您需要较少关注战略模式的"内部结构"，而更多地关注其设计目标/用途。

https://en.wikipedia.org/wiki/Strategy_pattern

策略模式（也称为策略模式）是一种软件设计模式，可以在运行时选择算法的行为。策略模式

  • 定义了一系列算法
  • 封装每个算法，以及
  • 使得算法在该家族中可互换

在我看来，你似乎真的打算"；创建"；基于某个输入值的字符串。

因此，你可能想要使用一个创造性模式

我的建议可能是Factory模式，或者可能是Builder模式。（两者都链接在创造模式链接中）

private string BuildQueryByEmployee(Employee emp) {
    // create your builder
    EmployeeQueryBuilder mBuilder = new EmployeeQueryBuilder ();
    // add # of positions
    mBuilder.addPositionCount(emp.Positions.Count);
    // add each position
    for (int i =0 ; i < emp.Positions.Count; i++ ){
        mBuilder.addPosition(emp.Positions[i]);
    }
    // 'build' your query. 
    // and return the query as a string.
    return mBuilder.buildQuery(); 
}

然后，在EmployeeQueryBuilder类中，您可以处理如何基于职位数量及其内容构建查询的复杂性。

其次，这里有一些链接可能对你有用。

  • https://en.wikipedia.org/wiki/Software_design_pattern（图案的一般光盘）
  • https://en.wikipedia.org/wiki/Design_Patterns（《四人帮》这本书本质上是关于设计模式的第一本书，值得读几遍，并用手把每个模式写几遍，直到你对它们感到满意，如果你以前没有使用过模式，单凭这一点就能把你的编码能力提高2~3倍。这本书中的例子有些过时，因为它的激励因素是写一个文本编辑器…但是仍然是"经典"，非常值得了解）
  • http://www.cs.wustl.edu/~schmidt/POSA/POSA2/（关于必须处理并发性的模式的第一本书之一）（POSA=面向模式的软件体系结构）（目前可能有些过头了，但总体来说"很好了解"）

我不认为战略模式是您想要的。我只想重构您的代码，将ifs提取到另一个方法中。

public List<Phone> GetListOfPhones(Employee emp)
{
   List<Phone> records = new List<Phone>();
   string query = BuildQueryByEmployeePosition(emp);
   var rawItems = QuerySPList(query);
   foreach (SPListItem item in rawItems)
   {
        //business logic 
   }
   return records;
}
private string BuildQueryByEmployeePosition(Employee emp) 
{
    if (emp.Positions.Count == 1 && emp.Positions[0] == "Regular")
        return "";// some querystring    
    if (emp.Positions.Count == 1 && emp.Positions[0] == "OfficeDirector")
        return "";// some querystring    
    if (emp.Positions.Count == 1 && emp.Positions[0] == "Admin")
        return "";// some querystring    
    if (emp.Positions.Count == 2 && emp.Positions.Contains("Regular") && emp.Positions.Contains("OfficeDirector"))
        return "";// some querystring    
    return ""; // some default query
}

这里有一个链接，可以很好地解释战略模式（以一个排序算法的实际例子）。

很高兴看到你是编程新手，正在学习模式，但是注意：在不需要它们的时候使用它们是一种反模式。

在我看来，最好使用一种STATE PATTERN和COMPOSITE。

示例：

  public abstract class Position
  {
    public abstract List<int> ListOfPhones();
  }
  public class Employer
  {
    public virtual IList<Position> CurrentPositions { get; set; }
  }
  public class Manager : Employer
  {
    public Manager(List<Position> positions)
    {
      this.CurrentPositions = positions;
    }
    public IEnumerable<int> GetNumbers()
    {
      foreach (Position position in this.CurrentPositions)
        foreach (var number in position.ListOfPhones())
          yield return number;
    }
  }

上面的代码是不完整的，只是为了让你了解想法。

我同意mawalker的观点，您不需要策略模式，因为在所有情况下都有相同的行为。你需要的是某种创造模式。我会使用Builder和责任链模式重构您的代码。

1） 实现基类：

public abstract class EmployeeHandler
{
  private readonly EmployeeHandler _nextHandler;
  protected EmployeeHandler(EmployeeHandler nextHandler)
  {
    _nextHandler = nextHandler;
  }
  public string BuildQuery(Employee emp)
  {
    if (CanHandle(emp))
    {
        return GetQuery(emp);
    }
    if (_nextHandler == null)
    {
        return string.Empty;
    }
    return _nextHandler.BuildQuery(emp);
  }
  protected abstract string GetQuery(Employee emp);
  protected abstract bool CanHandle(Employee emp);
}

2） 定义具体实施：

public class RegularEmployeeHandler : EmployeeHandler
{
  public RegularEmployeeHandler(EmployeeHandler nextHandler) : base(nextHandler) {
  }
  protected override bool CanHandle(Employee emp)
  {
    return emp.Positions.Count == 1 && emp.Positions[0] == "Regular";
  }
  protected override string GetQuery(Employee emp)
  {
    return "some regular query";
  }
}
public class OfficeDirectorEmployeeHandler : EmployeeHandler
{
  public OfficeDirectorEmployeeHandler(EmployeeHandler nextHandler) : base(nextHandler) {
  }
  protected override bool CanHandle(Employee emp)
  {
    return emp.Positions.Count == 1 && emp.Positions[0] == "OfficeDirector";
  }
  protected override string GetQuery(Employee emp)
  {
    return "some office director query"; 
  }
}
public class AdminEmployeeHandler : EmployeeHandler
{
  public AdminEmployeeHandler(EmployeeHandler nextHandler) : base(nextHandler) {
  }
  protected override bool CanHandle(Employee emp)
  {
    return emp.Positions.Count == 1 && emp.Positions[0] == "Admin";
  }
  protected override string GetQuery(Employee emp)
  {
    return "some admin query"; 
  } 
}
public class RegularAndOfficeDirectorEmployeeHandler : EmployeeHandler
{
  public RegularAndOfficeDirectorEmployeeHandler(EmployeeHandler nextHandler) : base(nextHandler) {
  }
  protected override string GetQuery(Employee emp)
  {
    return "some regular and director query";
  }
  protected override bool CanHandle(Employee emp)
  {
    return emp.Positions.Count == 2 && emp.Positions.Contains("Regular") && emp.Positions.Contains("OfficeDirector");
  }
}

3） 最后你的主类会变成这样：

public class YouMainClass
{
  private readonly EmployeeHandler _firstHandler;
  public YouMainClass()
  {
    var regularHandler = new RegularEmployeeHandler(null);
    var officeDirectorHandler = new OfficeDirectorEmployeeHandler(regularHandler);
    var adminHandler = new AdminEmployeeHandler(officeDirectorHandler);
    _firstHandler = new RegularAndOfficeDirectorEmployeeHandler(adminHandler);
  }
  public List<Phone> GetListOfPhones(Employee emp, IQueryBuilder queryBuilder)
  {
    List<Phone> records = new List<Phone>();
    string query = _firstHandler.BuildQuery(emp);
    var rawItems = QuerySPList(query);
    foreach (SPListItem item in rawItems)
    {
      //business logic 
    }
    return records;
  }
}
相关文章：