Properly Implementing the Specification Pattern

AndSpecification.cs

using System;

internal class AndSpecification<T> : ISpecification<T>
{
    private ISpecification<T> Specification1 { get; set; }
    private ISpecification<T> Specification2 { get; set; }

    internal AndSpecification(ISpecification<T> s1, ISpecification<T> s2)
    {
        Specification1 = s1;
        Specification2 = s2;
    }

    public bool IsSatisfiedBy(T entity)
    {
        return Specification1.IsSatisfiedBy(entity) && Specification2.IsSatisfiedBy(entity);
    }
}

ISpecification.cs

using System;

/// <summary>
/// A generic Specification.
/// <para>The Specification pattern is a behavioral 
/// pattern, whose purpose is to provide recombinable 
/// business logic in a boolean fashion.</para>
/// </summary>
/// <typeparam name="T">The type which the specification belongs.</typeparam>
public interface ISpecification<T>
{
    bool IsSatisfiedBy(T entity);
}

ISpecificationExtensions.cs

using System;

public static class ISpecificationExtensions
{
    public static ISpecification<T> And<T>(this ISpecification<T> s1, ISpecification<T> s2)
    {
        return new AndSpecification<T>(s1, s2);
    }

    public static ISpecification<T> Or<T>(this ISpecification<T> s1, ISpecification<T> s2)
    {
        return new OrSpecification<T>(s1, s2);
    }

    public static ISpecification<T> Not<T>(this ISpecification<T> s)
    {
        return new NotSpecification<T>(s);
    }
}

NotSpecification.cs

using System;

internal class NotSpecification<T> : ISpecification<T>
{
    private ISpecification<T> Specification { get; set; }

    internal NotSpecification(ISpecification<T> specification)
    {
        Specification = specification;
    }

    public bool IsSatisfiedBy(T candidate)
    {
        return !Specification.IsSatisfiedBy(candidate);
    }
}

OrSpecification.cs

using System;

internal class OrSpecification<T> : ISpecification<T>
{
    private ISpecification<T> Specification1 { get; set; }
    private ISpecification<T> Specification2 { get; set; }

    internal OrSpecification(ISpecification<T> s1, ISpecification<T> s2)
    {
        Specification1 = s1;
        Specification2 = s2;
    }

    public bool IsSatisfiedBy(T entity)
    {
        return Specification1.IsSatisfiedBy(entity) || Specification2.IsSatisfiedBy(entity);
    }
}