如何调整规范模式来评估对象的组合？

Question

我知道规范模式描述了如何使用实现 ISpecification的类层次结构来评估类型 T 的候选对象是否匹配特定规范（= 满足业务规则）。

我的问题：我想要实现的业务规则需要评估多个对象（例如，客户和合同）。

我的双重问题：

• 是否有规范模式的典型改编来实现这一目标？我只能考虑通过我的规范类删除 ISpecification 的实现，并在 isSatisfiedBy() 方法中获取尽可能多的参数。但通过这样做，我失去了将此规范与其他规范结合起来的能力。

• 这个问题是否揭示了我的设计中的缺陷？ （即我需要使用客户来评估什么，并且合同应该在另一个对象上评估，例如订阅，它可以包含所有必要的信息）？

Answer 1

在这种情况下（取决于规范具体应该做什么，我将使用其中一个对象作为规范主题，使用其他对象作为参数。

示例：

public class ShouldCreateEmailAccountSpecification : ISpecification<Customer>
{
    public ShouldCreateEmailAccountSpecification(Contract selectedContract)
    {
       SelectedContract = selectedContract;
    }

    public Contract SelectedContract { get; private set; }

    public bool IsSatisfiedBy(Customer subject)
    {
        return false;
    }
}

Answer 2

您的问题是您的规范接口使用通用类型参数，这阻止了它用于组合不同专业化（客户、合同）之间的评估逻辑，因为 ISpecification实际上是与 ISpecification不同的接口。您可以使用上面 Jeff 的方法，该方法摆脱类型参数并将所有内容作为基本类型（对象）传递。根据您使用的语言，您还可以将事情提升一个级别，并使用委托将规范与布尔逻辑结合起来。 C# 示例（不是特别有用，但可能会给您一些关于框架的想法）：

ISpecification<Customer> cust_spec = /*...*/
ISpecification<Contract> contract_spec = /*... */
bool result = EvalWithAnd( () => cust_spec.IsSatisfiedBy(customer), () => contract_spec.IsSatisfiedBy( contract ) );

public void EvalWithAnd( params Func<bool>[] specs )
{
    foreach( var spec in specs )
    {
       if ( !spec() )
          return false; /* If any return false, we can short-circuit */
    }
    return true; /* all delegates returned true */
}

Answer 3

Paco 的解决方案是使用构造函数注入将一个对象视为主体，将一个对象视为参数，有时可以起作用，但如果这两个对象都是在规范对象之后构造的，则事情会变得相当困难。

此问题的一种解决方案是使用参数对象，如以下重构建议所示：http://sourcemaking。 com/refactoring/introduce-parameter-object。

基本思想是，如果您认为 Customer 和 Contract 都是代表相关概念的参数，那么您只需创建另一个包含它们的参数对象即可。

public class ParameterObject  
{
    public Customer Customer { get; set; }
    public Contract Contract { get; set; }
}

然后你的通用规范就变成了该类型：

public class SomeSpecification : ISpecification<ParameterObject>
{
    public bool IsSatisfiedBy(ParameterObject candidate)
    {
        return false;
    }
}

Answer 4

我不知道我是否理解你的问题。

如果您对客户和合同使用相同的规范，则意味着您可以向它们发送相同的消息。这可以通过让它们都实现一个接口并使用这个接口作为T类型来解决。我不知道这在您的领域是否有意义。

抱歉，如果这不是您问题的答案。