使用策略模式替代多个if语句

Question

使用策略模式替代多个if语句

5

我有一个方法，其中有很多if语句，我根据员工职位筛选SharePoint列表。结果是查询字符串，作为参数传递给另一个方法QuerySPList。

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

我读到过，通过实现“策略模式”，我们可以避免使用大量的“if”代码混乱。然而，我是开发和设计模式的新手，所以我需要一些帮助。如果有人能指导我该怎么做并给我建议，欢迎回答我的问题。我有想法，但我觉得我走错了方向。我的想法是创建一个“接口IRoleHandler”，然后将其实现到3个类中，例如“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());

- Hank Mooody

我认为你过度设计了，你有多少个这样的东西？如果少于5个左右，你应该只使用case语句。 - Hogan

目前我有6个if语句，但将来可能会超过20个。 - Hank Mooody

这里有另一种思考方式——是角色定义了公司资产的业务规则，还是资产定义了角色的业务规则。真正决定电话数据库如何工作的是管理员吗？还是电话数据库或应用程序定义了管理员如何使用电话。在大多数情况下，是后者，因此将电话使用逻辑按角色对象拆分是没有意义的。 - Hogan

4个回答

3

我认为策略模式并不是你想要的。我建议将代码重构，将 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
}

这里有一个关于策略模式以及一种排序算法的真实例子的链接，非常不错。

很高兴看到您对编程和设计模式感兴趣，但要注意：在不需要时使用它们是一种反模式。

- fabriciorissetto

这很好，因为你实际上添加了一个工厂方法。但这不太适用于大规模。使用 Builder（我在我的答案中添加了示例代码）将会更有帮助。不幸的是，如果不知道这是否是完整的示例或此类/逻辑可能会多频繁地更改，就很难确定哪个更好。 - mawalker

0

我同意mawalker的观点，既然所有情况下的行为都相同，你就不需要策略模式。你需要的是某种创建型模式。我建议你使用生成器和责任链模式来重构代码。

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

- Dzianis Yafimau

0

在我看来，最好使用一种带有COMPOSITE的STATE PATTERN。

例如：

  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;

    }
  }

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

- Cleiton

您介意解释一下您为什么这样认为吗？我没看到好处。(是的，我知道他不使用原始数组，但他的问题是关于查询构建中的if语句。) - mawalker

我在编写时考虑了SRP，正如您所看到的，甚至可以使用组合将数据库职责委派到更低层次（例如，Position类可能需要一个数据库接口）。如果有一两个规则发生变化，我认为将来更改每个查询将非常容易。 - Cleiton

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- mawalker · Accepted Answer

首先，我认为您需要更少关注策略模式的“内部结构”，更应关注其设计目标和用途。

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

策略模式（也称为策略者模式）是一种软件设计模式，它使得算法的行为可以在运行时选择。策略模式定义了一组算法，封装了每个算法，并使得这些算法在该组中可以互换。对我来说，看起来你实际上是想根据某些输入值“创建”一个字符串。因此，你可能需要使用其中一种创建型模式。我的建议可能是工厂模式，或者可能是生成器模式。（链接在创建型模式链接中）

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 = 模式导向软件架构）（现在可能有点过度，但一般来说“了解一下”是好的）