每种算法具有不同方法签名的策略模式

Question

我正在对某些代码进行重构。

我们有一份投资者名单，每个人都分配了金额。总金额应该等于另一个总金额，但有时会有几美分的差异，因此我们使用不同的算法将这些差异分配给每个投资者。

目前的代码是这样的：

public void Round(IList<Investors> investors, Enum algorithm, [here goes a list of many parameters]) {

   // some checks and logic here - OMMITED FOR BREVITY

  // pick method given algorithm Enum

  if (algoritm == Enum.Algorithm1) {
      SomeStaticClass.Algorithm1(investors, remainders, someParameter1, someParameter2, someParameter3, someParameter4)
  } else if (algoritm == Enum.Algorithm2) {
     SomeStaticClass.Algorithm2(investors, remainders, someParameter3)
  }
}

到目前为止，我们只有两种算法。我必须实施第三个。我有机会重构现有的实现以及编写一些通用代码来为未来的算法制作此功能，可能为每个客户定制。

我的第一个想法是“好吧，这是一种策略模式”。但我看到的问题是两种算法都接收到不同的参数列表（前两个除外）。未来的算法也可以接收不同的参数列表。唯一的“共同点”是投资者名单和其余部分。

我该如何设计它以使界面更简洁？ 我想到了

1. 建立一个包含所有可能参数的接口，并共享它 在所有实现中。
2. 使用具有所有可能参数的对象作为属性，并将该通用对象用作接口的一部分。一世 将有 3 个参数：投资者列表、剩余对象和“参数”对象。但在这种情况下，我有一个类似的问题。实例化每个对象并填充所需的属性取决于算法（除非我设置了所有属性）。一世 必须使用工厂（或其他东西）来实例化它，使用界面中的所有参数，对吗？我会将参数过多的问题转移到那个“工厂”或其他什么地方。
3. 使用动态对象而不是静态类型对象。仍然 和以前一样的问题，实例化

我也想过使用访问者模式，但据我所知，如果我有不同的算法供不同的实体使用，比如另一类投资者，就会出现这种情况。所以我认为这不是正确的方法。

到目前为止，最让我信服的是第二个，尽管我对此仍然有些沉默。

有什么想法吗？

谢谢

Answer 1

策略有不同的实现。当所有替代的具体策略都需要相同的类型签名时，它很简单。但是当具体的实现开始从 Context 请求不同的数据时，我们必须通过放松封装优雅地退后一步（“破坏封装”是策略的已知缺点），我们可以将 Context 传递给策略方法签名或构造函数取决于需要多少。

通过使用接口并将大对象树分解成更小的容器，我们可以限制对大部分上下文状态的访问。

以下代码演示了传递方法参数。

    public class Context {
        private String name;
        private int id;
        private double salary;
        Strategy strategy;
        void contextInterface(){
            strategy.algorithmInterface(this);
        }
        public String getName() {
            return name;
        }
        public int getId() {
            return id;
        }
        public double getSalary() {
            return salary;
        }
    }

    public interface Strategy {
    // WE CAN NOT DECIDE COMMON SIGNATURE HERE
    // AS ALL IMPLEMENTATIONS REQUIRE DIFF PARAMS
    void algorithmInterface(Context context);
    }

    public class StrategyA implements Strategy{
        @Override
        public void algorithmInterface(Context context) {
            // OBSERVE HERE BREAKING OF ENCAPSULATION 
            // BY OPERATING ON SOMEBODY ELSE'S DATA
            context.getName();
            context.getId();
        }
    }

    public class StrategyB implements Strategy{
        @Override
        public void algorithmInterface(Context context) {
            // OBSERVE HERE BREAKING OF ENCAPSULATION 
            // BY OPERATING ON SOMEBODY ELSE'S DATA
            context.getSalary();
            context.getId();
        }
    }

Answer 2

好吧，我可能走错了方向……但是您将参数传递给 all 算法以及实际使用的算法的标识符似乎有点奇怪。理想情况下，Round() 函数不应该只是得到它需要操作的东西吗？

我正在想象 调用 Round() 的函数看起来像：

if (something)
    algToUse = Enum.Algorithm1;
else
    if (otherthing)
        algToUse = Enum.Algorithm2;
    else
        algToUse = Enum.Algorithm3;
Round(investors, remainder, algToUse, dayOfMonth, lunarCycle, numberOfGoblinsFound, etc);

...如果相反，你做了这样的事情会怎样：

public abstract class RoundingAlgorithm
{
    public abstract void PerformRounding(IList<Investors> investors, int remainders);
}
public class RoundingRandomly : RoundingAlgorithm
{
    private int someNum;
    private DateTime anotherParam;
    public RoundingRandomly(int someNum, DateTime anotherParam)
    {
        this.someNum = someNum;
        this.anotherParam = anotherParam;
    }
    public override void PerformRounding(IList<Investors> investors, int remainder)
    {
        // ... code ...
    }
}
// ... and other subclasses of RoundingAlgorithm

// ... later on:
public void Round(IList<Investors> investors, RoundingAlgorithm roundingMethodToUse)
{
    // ...your other code (checks, etc)...

    roundingMethodToUse.Round(investors, remainders);
}    

...然后你之前的函数看起来像：

RoundingAlgorithm roundingMethod;
if (something)
    roundingMethod = new RoundingByStreetNum(1, "asdf", DateTime.Now);
else
    if (otherthing)
        roundingMethod = new RoundingWithPrejudice(null);
    else
        roundingMethod = new RoundingDefault(1000);
Round(investors, roundingMethod);

...基本上，无需填充该枚举值，只需创建一个 RoundingAlgorithm 对象并将其传递给 Round()。