设计模式-规约模式C#版

设计模式-规约模式C#版
规约模式的使用场景就是规则，业务规则的碎片化。
业务规则的组合是不固定的，需要做成很容易组合，也很容易拆散的方式，规约模式是一个选择。
下面的例子是一个书店中，用户租书的场景。
需要判断用户的最大租书数和用户的状态，需要同时满足这两个要求，才可以继续租书。最大租书数和状态这两个规则拆散开来，在需要的时候再进行组合。不需要组合的地方，就单独使用这些规则。
针对一个实体有不同的规则，把这些规则碎片化，随意组合和拆散，这样就构成了规约模式。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DomainModel.Model
{
    /// <summary>
    /// 规约模式
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface ISpecification<T>
    {
        bool IsSatisfiedBy(T entity);
        /// <summary>
        /// 与规约
        /// </summary>
        /// <param name="specification"></param>
        /// <returns></returns>
        ISpecification<T> And(ISpecification<T> specification);
        /// <summary>
        /// 或规约
        /// </summary>
        /// <param name="specification"></param>
        /// <returns></returns>
        ISpecification<T> Or(ISpecification<T> specification);
        /// <summary>
        /// 非规约
        /// </summary>
        /// <returns></returns>
        ISpecification<T> Not();
    }

    public class Customer
    {
        private ISpecification<Customer> _hasReachedMax;
        private ISpecification<Customer> _active;

        public Customer(ISpecification<Customer> hasReachedMax, ISpecification<Customer> active)
        {
            this._hasReachedMax = hasReachedMax;
            this._active = active;
        }
        public int TotalRentNumber { get; set; }
        public bool Active
        {
            get { return true; }
        }

        public bool CanRent()
        {
            var specification = this._hasReachedMax.Not().And(this._active.Not());
            return specification.IsSatisfiedBy(this);
        }
    }

    public class HasReachedMaxSpecification : CompositeSpecification<Customer>
    {
        public override bool IsSatisfiedBy(Customer entity)
        {
            return entity.TotalRentNumber >= 6;
        }
    }
    public class CustomerActiveSpecification : CompositeSpecification<Customer>
    {
        public override bool IsSatisfiedBy(Customer entity)
        {
            return entity.Active;
        }
    }
    /// <summary>
    /// 组合规约
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class CompositeSpecification<T> : ISpecification<T>
    {

        public abstract bool IsSatisfiedBy(T entity);

        public ISpecification<T> And(ISpecification<T> specification)
        {
            return new AndSpecification<T>(this, specification);
        }

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

        public ISpecification<T> Or(ISpecification<T> specification)
        {
            throw new NotImplementedException();
        }

    }

    public class AndSpecification<T> : CompositeSpecification<T>
    {
        private ISpecification<T> _left;
        private ISpecification<T> _right;
        public AndSpecification(ISpecification<T> left, ISpecification<T> right)
        {
            this._left = left;
            this._right = right;
        }
        public override bool IsSatisfiedBy(T entity)
        {
            return this._left.IsSatisfiedBy(entity) && this._right.IsSatisfiedBy(entity);
        }
    }

    public class OrSpecification<T> : CompositeSpecification<T>
    {
        private ISpecification<T> _left;
        private ISpecification<T> _right;
   &

补充：软件开发 , C# ,