Specification pattern

The Specification pattern has been added to NGenerics . In my previous post on the Specification Pattern, we explored creating specification functionality using extension methods. It’s been implemented with the operator methods (And, Or, Xor) on the actual interface, with an abstract class forming the base of all specifications. The deal-breaker for this approach was the need to add operators |, & and ^ to trim down the syntax some. With the Specification Pattern in NGenerics, you can now do this:

C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Customer
{
    public string Name { get; set; }
    public string Surname { get; set; }
    public CustomerStatus Status { get; set; }
    public BalanceStatus BalanceStatus { get; set; }
}

 public enum BalanceStatus
 {
     Settled,
     Owing
 }

public enum CustomerStatus
{
    Bronze,
    Silver,
    Gold
}

public bool ValidateGoldCustomer()
{
    var specification = new PredicateSpecification(x => x.Status == CustomerStatus.Gold)
                .And(x => x.Name == "CustomerName")
                .And(x => x.BalanceStatus ==  BalanceStatus.Settled).Not();

    var testCustomer = new Customer
        {
            Name = "CustomerName",
            Surname = "CustomerSurname",
            Status = CustomerStatus-.Gold
        };
    return specification.IsSatisfiedBy(testCustomer);
}

Or you can use the operators defined in AbstractSpecification<T>:

C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public bool ValidateGoldCustomerWithOperators()
{
    var specification = new PredicateSpecification(x => x.Status == CustomerStatus.Gold) &
        new Predicate(x => x.Name == "CustomerName") &
        !new PredicateSpecification(x => x.BalanceStatus == BalanceStatus.Settled);

    var testCustomer = new Customer
        {
            Name = "CustomerName",
            Surname = "CustomerSurname",
            Status = CustomerStatus.Gold
        };

    return specification.IsSatisfiedBy(testCustomer);
}

The part I’m looking into now is subsumption and partially satisfied specifications. From Martin Fowler and Eric Evans’ paper :

Subsumption allows you to compare specifications to see if satisfying one implies satisfaction of the other. It is also sometimes possible to use subsumption to implement satisfaction. If a candidate object can produce a specification that characterizes it, the testing with a specification then becomes a comparison of similar specifications — removing the coupling of specification mechanism entirely from the domain.

Photo by William Felker on Unsplash