可维护性的设计模式问题

Question

我不确定这里是否应该使用某种模式，但情况如下：

我有许多实现接口的具体类：

public interface IPerformAction
{
   bool ShouldPerformAction();
   void PerformAction();
}

我有另一个类检查输入以确定是否应该执行 ShouldPerformAction。问题在于，新检查的添加相当频繁。检查类的接口定义如下：

public interface IShouldPerformActionChecker
{
   bool CheckA(string a);
   bool CheckB(string b);
   bool CheckC(int c);
   // etc...
}

最后，我目前让具体类使用特定于该具体类的数据调用每个检查器方法：

public class ConcreteClass : IPerformAction
{
   public IShouldPerformActionCheck ShouldPerformActionChecker { get; set; }

   public string Property1 { get; set; }
   public string Property2 { get; set; }
   public int Property3 { get; set; }

   public bool ShouldPerformAction()
   {
      return 
         ShouldPerformActionChecker.CheckA(this.Property1) ||
         ShouldPerformActionChecker.CheckB(this.Property2) ||
         ShouldPerformActionChecker.CheckC(this.Property3);
   }

   public void PerformAction()
   {
      // do something class specific
   }
}

现在每次添加新检查时，我都必须重构具体类以包含新检查。每个具体类将不同的属性传递给检查方法，因此子类化具体类不是一种选择。关于如何以更清洁的方式实现这一点的任何想法？

Answer 1

让我们退后一步 - 你为什么首先使用接口？ IShouldPerformActionCheck 的单个实现可以在IPerformAction 的多个实现之间共享吗？答案似乎是否定的，因为 ICheck 必须了解 Action 上特定于实现的属性（Property1、Property2、Property3）才能执行检查。因此，IAction 和 ICheck 之间的关系需要比 IAction 合约提供给 ICheck 更多的信息。看来您的 Check 类应该基于与它们检查的特定类型的操作耦合的具体实现，例如：

abstract class CheckConcreteClass
{
    abstract void Check(ConcreteClass concreteInstance);
}

Answer 2

“CheckA”、“CheckB”等名称，大概是为了避免暴露机密信息而选择的，也混淆了类之间关系的性质，所以我不得不说一下。

但是，这非常接近 double dispatch，除非您正在执行中间对象的转换。

编辑：尝试“按书”播放双重调度模式，而不是在调度中分解对象。为此，您需要以下内容：

public interface IPerformAction
{
    bool ShouldPerformAction(IShouldPerformActionChecker checker);
    void PerformAction();
}

public interface IShouldPerformActionChecker
{
    bool CheckShouldPerformAction(FloorWax toCheck);
    bool CheckShouldPerformAction(DessertTopping toCheck);
    // etc...
}

public class FloorWax : IPerformAction
{
    public string Fragrance { get; set; }

    // Note that the text of this method is identical in each concrete class,
    // but compiles to call a different overload of CheckShouldPerformAction.
    public bool ShouldPerformAction(IShouldPerformActionChecker checker)
    {
        return checker.CheckShouldPerformAction(this);
    }
}

public class DessertTopping: IPerformAction
{
    public string Flavor { get; set; }

    // Note that the text of this method is identical in each concrete class,
    // but compiles to call a different overload of CheckShouldPerformAction.
    public bool ShouldPerformAction(IShouldPerformActionChecker checker)
    {
        return checker.CheckShouldPerformAction(this);
    }
}

public class ShimmerApplicationChecker : IShouldPerformActionChecker
{
    // handles binding of FloorWax class to required checks
    public bool CheckShouldPerformAction(FloorWax toCheck)
    {
        return CheckAroma(toCheck.Fragrance);
    }

    // handles binding of DessertTopping class to required checks
    public bool CheckShouldPerformAction(DessertTopping toCheck);
    {
        return CheckAroma(toCheck.Flavor);
    }

    // some concrete check
    private bool CheckAroma(string aroma)
    {
        return aroma.Contains("chocolate");
    }
}

Answer 3

您可以将检查合并到一个接受对象的通用方法中：

public interface IShouldPerformActionChecker
{
   bool Check(object o);
}

然后在您的具体类中列出这些检查：

public List<IShouldPerformActionCheck> ShouldPerformActionChecker { get; set; }

类型安全性较低，但更灵活。

您可以考虑使用Predicate<T> 委托，而不是使用IShouldPerformActionCheck，它的作用大致相同。

Answer 4

当您创建一个新的CheckN 时，无论如何您都必须在每个具体的检查器类中实现它，不是吗？

或者您是在谈论重构您的 IPerformActions 以实际调用该检查？

你为什么不只是一个调用所有东西的CheckAll？

Answer 5

不是让具体类尝试检查是否应该执行操作，可能有一种更易于维护的方式来排列这些对象。

如果检查器实际实现了 IPerformAction，并且有一个 IPerformAction 成员，如果应该执行该操作，它会调用该成员怎么办？该成员可以是链中的另一个检查器，或者如果所有条件都已通过，则执行该操作的实际类？

要做到这一点可能需要你稍微重构一下，以便执行操作的逻辑包含在一个类中，而要使用的特定数据在另一个类中（有点像命令模式），这样跳棋可以做他们的工作。

通过这种方式，您可以轻松添加另一个验证规则，只需将其放入导致最终操作的对象“链”中。

Answer 6

你可以试试这样的：

List<IShouldPerformActionChecker> checkers = new List<IShouldPerformActionChecker>();

//... add in each checker to try

foreach(ConcreteClass objectToCheck in checkset) {
   bool isGood = true;
   foreach(IShouldPerformActionChecker checker in checkers) {
      isGood &= checker.DoCheck(objectToCheck.Property);

       if (!isGood) { break; }
   }

   //handle failed check here
}