标签: specification-pattern

尝试执行linq查询时出现以下错误:

LINQ to Entities无法识别方法'Boolean IsCharityMatching(System.String,System.String)'方法,并且此方法无法转换为商店表达式.

我已经阅读了很多以前的问题,人们会得到相同的错误,如果我理解正确,那是因为LINQ to Entities需要将整个linq查询表达式转换为服务器查询,因此你不能调用外部方法在里面.我无法将我的场景转换成有效的东西,我的大脑开始融化,所以我希望有人能指出我正确的方向.我们正在使用实体框架和规范模式(我对两者都是新手).

这是使用规范的代码:

ISpecification<Charity> specification = new CharitySearchSpecification(charityTitle, charityReference);

charities = charitiesRepository.Find(specification).OrderBy(p => p.RegisteredName).ToList();

这是linq表达式:

public System.Linq.Expressions.Expression<Func<Charity, bool>> IsSatisfied()
{
    return p => p.IsCharityMatching(this.charityName, this.charityReference);
}

这是IsCharityMatching方法:

public bool IsCharityMatching(string name, string referenceNumber)
{
    bool exists = true;

    if (!String.IsNullOrEmpty(name))
    {
        if (!this.registeredName.ToLower().Contains(name.ToLower()) &&
            !this.alias.ToLower().Contains(name.ToLower()) &&
           !this.charityId.ToLower().Contains(name.ToLower()))
        {
            exists = false;
        }
    }

    if (!String.IsNullOrEmpty(referenceNumber))
    {
        if (!this.charityReference.ToLower().Contains(referenceNumber.ToLower()))
        {
            exists = false;
        }
    }

    return exists;
}

如果您需要更多信息,请与我们联系.

非常感谢,

Annelie

我一直在寻找一个很好的解决方案来解决典型的Repository模式所带来的问题(专门的查询方法的增长列表等等.请参阅:http://ayende.com/blog/3955/repository-是新单身人士).

我非常喜欢使用Command查询的想法,特别是通过使用规范模式.但是,我的规范问题是它只涉及简单选择的标准(基本上是where子句),而不涉及查询的其他问题,例如连接,分组,子集选择或投影等.基本上,许多查询必须通过所有额外的箍来获得正确的数据集.

(注意:我在命令模式中使用术语"命令",也称为查询对象.我不是在命令/查询分离中讨论命令,其中查询和命令之间存在区别(更新,删除,插入))

因此,我正在寻找封装整个查询的替代方案,但仍然足够灵活,以至于您不仅仅需要交换spaghetti Repositories以进行大量的命令类.

我已经使用过,例如Linqspecs,虽然我发现能够为选择标准指定有意义的名称有一些价值,但这还不够.也许我正在寻找一种结合多种方法的混合解决方案.

我正在寻找其他人可能已经开发的解决方案,以解决这个问题,或解决不同的问题,但仍满足这些要求.在链接的文章中,Ayende建议直接使用nHibernate上下文,但我觉得这很大程度上使您的业务层复杂化,因为它现在还必须包含查询信息.

等待期过后,我会在此提供赏金.因此,请提供有价值的解决方案,并提供良好的解释,我将选择最佳解决方案,并向选手投票.

注意:我正在寻找基于ORM的东西.不必明确是EF或nHibernate,但这些是最常见的并且最适合.如果它可以很容易地适应其他ORM,那将是一个奖励.Linq兼容也不错.

更新:我真的很惊讶这里没有很多好的建议.似乎人们完全是CQRS,或者他们完全在资源库中.我的大多数应用程序都不够复杂,无法保证CQRS(大多数CQRS倡导者都会说你不应该使用它).

更新:这里似乎有点混乱.我不是在寻找新的数据访问技术,而是在业务和数据之间设计合理的界面.

理想情况下,我正在寻找的是Query对象,规范模式和存储库之间的某种交叉.正如我上面所说,规范模式只处理where子句方面,而不是查询的其他方面,如连接,子选择等.存储库处理整个查询,但一段时间后失控.查询对象也处理整个查询,但我不想简单地用查询对象的爆炸替换存储库.

我正在检查"Promises/A +"规范,但无法理解以下内容:

在第1节.术语,

1.1."promise”是一个具有then方法的对象或函数,其行为符合此规范.

1.2.“thenable”是定义then方法的对象或函数.

那么术语"thenable"和有"promise"什么区别？

同样在2.3节.承诺解决程序,

promise解析过程是一个抽象操作,它将promise和value作为输入,我们将其表示为[[Resolve]](promise, x).

所以我的问题是:

为什么在2个开始和结束括号内表示？有没有约定？

非常感谢你.

在阅读了LosTechies.com的Chris Missal关于规范模式的一系列博客(这里和这里)后,我真的很想找到更完整的例子.有谁知道我在哪里可以找到一个更加充实的例子,或者可能是一个使用这种模式的开源项目？

我必须使用数百行以下代码实现某些业务规则

if this
      then this
else if
      then this
.
. // hundreds of lines of rules
 else
      that

我们是否有任何设计模式可以有效地实现这一点或重用代码,以便它可以应用于所有不同的规则.我听说过规范模式,它创建了类似下面的内容

public interface Specification {

boolean isSatisfiedBy(Object o);

Specification and(Specification specification);

Specification or(Specification specification);

Specification not(Specification specification);
}


public abstract class AbstractSpecification implements Specification {

public abstract boolean isSatisfiedBy(Object o);

public Specification and(final Specification specification) {
 return new AndSpecification(this, specification);
}

public Specification or(final Specification specification) {
 return new OrSpecification(this, specification);
}

 public Specification not(final Specification specification) {
 return new NotSpecification(specification); …

我只是想知道规范模式是否毫无意义,给出以下示例:

假设您要检查客户是否在他/她的帐户中有足够的余额,您可以创建如下规范:

new CustomerHasEnoughMoneyInTheirAccount().IsSatisfiedBy(customer)

但是,我想知道的是,我可以通过在Customer类中使用Property getter来实现规范模式的相同"好处"(例如只需要在适当的位置更改业务规则),如下所示:

public class Customer
{

     public double Balance;

     public bool HasEnoughMoney
     {
          get { return this.Balance > 0; }
     }
}

来自客户代码:

customer.HasEnoughMoney

所以我的问题确实是; 使用属性getter来包装业务逻辑和创建Specification类之间有什么区别？

谢谢大家!

我创建了一个工厂和一组规范来创建和验证聚合根.目前我对工厂进行了一些测试,这些测试称工厂的产品规格,但我想知道这是否足够.从设计的角度来看,将工厂与其产品的规格相结合可能会更好,因为它们密切相关.

如果聚合根产品的规范用于验证而不是用于创建,那么从工厂内部调用它是否有意义？

或者单位测试是否足够好？

维基百科指出,规范模式是通过使用布尔逻辑将业务逻辑链接在一起来重新组合业务逻辑的地方.关于从列表或集合中选择过滤对象,在我看来,Dynamic LINQ允许我完成同样的事情.我错过了什么吗？是否还应考虑规格模式的其他好处？

编辑:

我发现了一些讨论组合LINQ和规范模式的帖子:

Linq规格项目

通过Nicqas Blumhardt(Autofac dude)通过Linq实施规范模式

有没有人走过这条路并且维护起来变得复杂了？

所以,我在这里查看了一些关于规范模式的帖子,但还没有找到答案.

我的问题是,在一个n层架构中,我应该在哪些规范中获得"新建"？

1. 我可以将它们放在我的服务层(也就是说,应用层,它有时被称为......基本上,.aspx代码隐藏的东西会与之交谈),但我觉得通过这样做,我让业务规则漏掉了域名.如果以其他方式(除了服务层)访问域对象,则域对象无法强制执行自己的业务规则.

2. 我可以通过构造函数注入将规范注入到我的Model类中.但同样,这感觉"错误".我觉得唯一应该注入Model类的是"服务",比如缓存,日志记录,脏标记跟踪等等......如果你能避免它,那么使用Aspects而不是乱丢模型的构造函数具有大量服务接口的类.

3. 我可以通过方法注入(有时称为"Double Dispatch")注入规范,并明确地使用该方法封装注入的规范以强制执行其业务规则.

4. 创建一个"域服务"类,它将通过构造函数注入获取规范,然后让服务层使用域服务来协调Domain对象.这对我来说似乎没问题,因为规范强制执行的规则仍然在"域"中,而Domain Service类的命名方式与它正在协调的Domain对象非常相似.这里的事情是我觉得我正在编写大量的类和代码,只是为了"正确"实现规范模式.

除此之外,相关规范要求存储库以确定它是否"满意".

这可能会导致性能问题,尤其是 如果我使用构造函数注入b/c消耗代码可以调用一个可能包装规范的属性,并且反过来调用数据库.

所以任何想法/想法/链接到文章？

新产品和使用规格的最佳位置在哪里？

我已经选择了一个使用规范模式的项目,这是我之前没有使用的模式,我不得不去研究模式.我注意到它没有orderby和skip/take功能,我找不到任何显示如何用模式实现它的地方.

我正在努力思考如何最好地将其添加到规范模式中.但我遇到了问题,比如规范处理"表达式",而我认为我不能将它与orderby等一起存储

基本上有一个这样的类:

public class Specification<T> : ISpecification<T>
{
    public Expression<Func<T, bool>> Predicate { get; protected set; }

    public Specification(Expression<Func<T, bool>> predicate)
    {
        Predicate = predicate;
    }

    public Specification<T> And(Specification<T> specification)
    {
        return new Specification<T>(this.Predicate.And(specification.Predicate));
    }

    public Specification<T> And(Expression<Func<T, bool>> predicate)
    {
        return new Specification<T>(this.Predicate.And(predicate));
    }

    public Specification<T> Or(Specification<T> specification)
    {
        return new Specification<T>(this.Predicate.Or(specification.Predicate));
    }

    public Specification<T> Or(Expression<Func<T, bool>> predicate)
    {
        return new Specification<T>(this.Predicate.Or(predicate));
    }

    public T SatisfyingItemFrom(IQueryable<T> query)
    {
        return query.Where(Predicate).SingleOrDefault();
    }

    public IQueryable<T> SatisfyingItemsFrom(IQueryable<T> query)
    {
        return query.Where(Predicate); …