Question

我有一个巨大的切换/案例声明，我想用策略模式替换。每个语句都具有很强的代码执行特定逻辑。有没有人在这种情况下有一个很好的使用模式的例子，或者你有任何其他好的解决方案吗？

我的解决方案

class Context
{
    private readonly List<CalculationUnit> _calculationsUnits;

    public Context()
    {
        _calculationsUnits = new List<CalculationUnit>()
                                 {
                                     new CalculationUnitA("calc1"),
                                     new CalculationUnitB("calc2"),
                                     new CalculationUnitC("calc2")
                                 };
    }

    public int Calculate(string name)
    {
        return (from c in _calculationsUnits where c.Name.Equals(name) select c.Calculate()).FirstOrDefault();
    }
}

class CalculationUnit
{
    public string Name { get; private set; }

    public CalculationUnit(string name)
    {
        Name = name;
    }

    public virtual int Calculate()
    {
        return 0;
    }
}

class CalculationUnitA : CalculationUnit
{
    public CalculationUnitA(string name) : base(name) { }

    public override int Calculate()
    {
        //calculations logic A
    }
}

class CalculationUnitB : CalculationUnit
{
    public CalculationUnitB(string name) : base(name) { }

    public override int Calculate()
    {
        //calculations logic A
    }
}

class CalculationUnitC : CalculationUnit
{
    public CalculationUnitC(string name) : base(name) { }

    public override int Calculate()
    {
        //calculations logic A
    }
}

但接下来我最终将会有50个类实现每个逻辑......

谢谢

Answer 1

strategy pattern通过将每个分支中的大部分代码重构为单独的类（或方法）来帮助实现。然后，您的交换机只是选择适当的策略类（或方法委托）的情况，然后通过单个调用在switch语句的末尾执行。因此大致如下：

switch (...)
{
    case ...:
        // Horrible logic;
        break;
    ...
}

变成这样：

ILogicImplementer implementer;
switch (...)
{
    case ...:
        implementer = new FirstCaseImplementer();
        break;
    ...
}
implementer.Implement();

您需要将逻辑重构为实现公共接口（或扩展公共基类）的一系列类，或者重构为具有兼容签名的一系列方法，以便您的策略可以选择匹配的委托。正如Oded在他的评论中暗示的那样，你不一定要摆脱select这样做，但每个案例都会变得更小。

从简短的描述中，它听起来像是使代码更简单，更易于维护的适当方法。

切换/案例到战略模式

1 个答案: