Implementing a strategy strategy instead of several if statements

Question

I have this method with a lot if statementsin which I filter SharePoint listbased on the employee’s position. The result is query stringthat which is passed as a parameter to another method 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;
}}

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

Answer 1

-, , " " /.

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

( ) , .

• ,
• .

, "" .

, ,

Factory Pattern , , 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/ ( , Concurrency) (POSA = ) ( , , " " )

Answer 2

, - , . , 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
}

, ( ).

, , : , , - -.

Answer 3

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;

    }
  }

, .

Answer 4

I agree with mawalker, you do not need a strategy template, since you have the same behavior for all cases. What you need is some kind of creative model. I would reorganize your code using the Builder and Chain of Responsibility templates .

1) Implement the base class:

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) Define specific implementations:

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) And finally, the main class will be changed as follows:

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