Specifications, Policies, and Composition

BaseRepository.cs

public virtual IQueryable<T> Query(ISpecification<T> query)
{
    var specifications = new List<ISpecification<T>>();
	
    _specificationPolicies
        .Where(p => p.Applies<T>())
        .Select(p => p.Build<T>())
        .Each(specifications.Add);

    _entityPolicies
        .Where(p => p.Applies())
        .Select(p => p.Build())
        .Each(specifications.Add);

    specifications.Add(query);

    var specification = _specificationComposer.Compose(specifications);
    return Entities.Where(specification.IsSatisfied());
}

BaseRepositoryExtensions.cs

public static IQueryable<TEntity> Query<TEntity>(this IEntityRepository<TEntity> repository, Expression<Func<TEntity, bool>> predicate)
{
    return repository.Query(predicate.ToSpecification());
}

FindByUserId.New.cs

public User FindByUserId(int userId)
{
    return this.Query(u => u.UserId == userId).SingleOrDefault();
}

FindByUserId.Old.cs

public User FindByUserId(int userId)
{
    return DataContext.Users.SingleOrDefault(u => u.UserId == userId);
}

IRepository.cs

public interface IRepository
{
    IQueryable<TEntity> Query<TEntity>(ISpecification<TEntity> query);
}

ISpecification.cs

public interface ISpecification<T>
{
    Expression<Func<T, bool>> IsSatisfied();
}

ISystemSpecificationPolicy.cs

public interface ISystemSpecificationPolicy
{
    bool Applies<TEntity>();
    ISpecification<TEntity> Build<TEntity>();
}

public interface ISystemSpecificationPolicy<TEntity>
{
    bool Applies();
    ISpecification<TEntity> Build();
}

QueryExtensions.cs

public static class QueryExtensions
{
    public static ISpecification<TEntity> ToSpecification<TEntity>(this Expression<Func<TEntity, bool>> predicate)
    {
        return new LambdaSpecification<TEntity>(predicate);
    }
	
    public static IQueryable<TEntity> Query<TEntity>(this IRepository repository, Expression<Func<TEntity, bool>> predicate)
    {
        return repository.Query(predicate.ToSpecification());
    }
}

SiteContextualEntityPolicy.cs

public class SiteContextualEntityPolicy : ISystemSpecificationPolicy
{
    private readonly SiteSettings _siteSettings;

    public SiteContextualEntityPolicy(SiteSettings siteSettings)
    {
	    _siteSettings = siteSettings;
    }

    public bool Applies<TEntity>()
    {
	    return typeof (ISiteContextualEntity).IsAssignableFrom(typeof (TEntity));
    }

    public ISpecification<TEntity> Build<TEntity>()
    {
	    return Specification
		    .For<ISiteContextualEntity>()
		    .Constrain<TEntity>(e => e.SiteId, _siteSettings.PrincipalSiteId);
    }
}