Filter()<\/code> on a repository<\/em>, which takes care of filtering the domain model<\/em> by the specifications. Thus, you bypass the need for having several special methods in your repository which take care of the actual filter operation (such as FilterByCustomerName()<\/code>, FilterByCustomerAddress()<\/code> etc.).<\/p>\nAn example interface snippet for a repository of persons with a specification filter method could then be:<\/p>\n
interface IPersonRepository\r\n{\r\n IEnumerable<Person> Filter(ISpecification<Person>\u00a0filterTerm);\r\n \/\/ ...\r\n}<\/pre>\nSummarized, some key benefits of the Specification Pattern are:<\/p>\n
\n- Loose coupling<\/em> of the filter logic from the objects being filtered,<\/li>\n
- Single responsibility<\/em>: Interface of repository\/data provider isn’t polluted with lots of filter methods,<\/li>\n
- Callers can express in a flexible<\/em> way by which criteria entities can be filtered,<\/li>\n
- Composition<\/em> of specifications (e.g. by a fluent interface<\/a>) yields to flexible filter queries, for example:
\n[sourcecode language=’c#‘]var filter = Filter.By(25).And(„Frankfurt“)[\/sourcecode]<\/workingin><\/ageabove><\/person><\/li>\n<\/ul>\nBut now the provocative question that one could come with: Who needs the Specification Pattern in times of C# 3.0 and Expressions?<\/strong> This might sound disturbing at first, but let me explain…
\nC# 3.0 came up with the new concept of Expressions\/Expression trees. This way, code can be treated as a kind of syntax tree in the program. Developers can extend the tree with additional code portions and then compile it into executable code which can be invoked.<\/p>\nTherefore Expressions seem to give us similar benefits for filtering as specifications do. By using Expressions, we are able to define a single Filter()<\/code> method on the repository, which gets an appropriate Expression as argument. Consumers of the repository can call this method with their custom filter Expressions and thus we’ve got the same benefits: loose coupling of filter logic and objects to be filtered, flexibility for callers to provide custom filter criteria and the possibility to combine several filter criteria (several Expressions).
\nOne could argue that with specifications we’ve got better encapsulation of the filter logic into separate classes. But this can be done with Expressions as well (e.g. by separate wrapper classes or dedicated Expression providers), so that isn’t a good argument…<\/p>\nThe interface of a repository of persons with a filter that uses Expressions might look like this:<\/p>\n
interface IPersonRepository\r\n{\r\n IEnumerable<Person> Filter(Expression<Predicate<Person>> filterTerm);\r\n \/\/ ...\r\n}<\/pre>\nThis leads again to the question: Do we still need the Specification Pattern or is it already embedded with Expressions in the language (C# 3.0) itself?<\/p>\n
Pattern focus<\/h4>\n
First I want to mention that the intent of a pattern<\/em> is not (only) to provide a technical solution, but also a conceptual guideline for a problem at hand. Thus Expressions as technical solution don’t cover the intent of the Specification Pattern. The Specification Pattern can be implemented with the help of Expressions, but that’s another point. So, directly comparing the Specification Pattern with Expressions is like an apple-pear-comparison.<\/p>\nEncapsulation focus<\/h4>\n
Let’s come to use cases when I would prefer the use of dedicated specification classes rather than directly using Expressions.
\nFirst as a team lead you could want to enforce the use of dedicated specification classes in your development team (thus enforce encapsulation of the filter logic). By giving Expressions or Predicates to filter methods directly,\u00a0 developers would be allowed to define filter expressions whereever they want to. You don’t have the control over this process and please don’t trust your project guidelines: If developers are allowed to do something wrong, they will do.<\/p>\n
With specifications you can force your team members to write specification classes for their requirements, which leads to enforced encapsulation<\/em>. Furthermore you drive reuse<\/em> of existing specification classes. Other developers are encouraged to use existing specifications, especially because of the additional effort for writing new specifications. By combining several specifications, the reusability aspect is pushed even more.<\/p>\nDomain model focus<\/h4>\n
Giving consumers the full flexibility of defining custom filter criteria with specifications can be very handsome in many situations. However, in other scenarios instead of giving full flexibility, you may want to restrict the set of filters for your domain model. If you focus on your domain, you perhaps want a restricted set of specifications, each with a very specific meaning in your domain! Binding such specifications to your domain model makes the purpose of your domain and how it can\/should be used in terms of filtering much clearer.<\/p>\n
Technically, in order to restrict access to a particular set of specifications, you could create sealed specification classes inside<\/em> of your domain model services (same layer as repository). Consumers of the repository would be allowed to call the Filter()<\/code> method on the repository with those specifications (and compositions of those), but they would not be able to create new specifications if you don’t mark the specification interface as public. This way you get two characteristics: Restricted filtering, which fits into your domain and your use cases on the one hand, and encapsulation\/separation of filter logic and entities which should be filtered on the other hand.<\/p>\nBottom line<\/h4>\n
This article started with an interesting and provocative question: Is the Specification Pattern obsolete? This question came up with a look at Expressions in C# 3.0. Technically you can achieve similar results when using Expressions instead of implementing the Specification classes by hand. But as the last sections have shown, in my opinion the Specification Pattern is not<\/em> obsolete! As pattern<\/em> it’s adding very specific value to the plain technical solution, when you take encapsulation and domains into account. Then it clearly goes beyond the technical aspect which many developers see at first sight.<\/p>\nThose are my current thoughts on specifications, but of course my opinions are not carved in stone. What do you think? What points I’ve missed perhaps? I’m eager for your comments!<\/p>\n
![\"kick](\"http:\/\/www.dotnetkicks.com\/Services\/Images\/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.leading-edge-dev.de%2f%3fp%3d466\")
<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"I’m a guy who loves many of the new patterns that I get to know. But sometimes when I show that pattern to colleagues around me, they tilt their heads and say: „Arrrm, who needs this?“. Often they help me to get back to the ground and think again about intents and benefits of one … Is the Specification Pattern obsolete?<\/span> weiterlesen<\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11,7,12],"tags":[177,175,176],"class_list":["post-466","post","type-post","status-publish","format-standard","hentry","category-architecture","category-c-sharp","category-design-patterns","tag-expressions","tag-patterns","tag-specification-pattern"],"_links":{"self":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/466","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/comments?post=466"}],"version-history":[{"count":36,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/466\/revisions"}],"predecessor-version":[{"id":936,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/466\/revisions\/936"}],"wp:attachment":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/media?parent=466"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/categories?post=466"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/tags?post=466"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}