规格模式（Specification）

需求如下：需要从数据库的Cargo表中取出商品名称为“钉子”的货物。

可以这样做：

   
   
   
   

    
    
    
    public
    
    
    
     
    
    
    
    class
    
    
    
     CargoRepository
{
 
    
    
    
    public
    
    
    
     List SelectByPartName(
    
    
    
    string
    
    
    
     partName){}
}
   
   
   
   

当需求发生变化了，它要从数据库的Cargo表中取出商品编码为“0001”的货物。

可以这样做：

   
   
   
   

    
    
    
    public
    
    
    
     
    
    
    
    class
    
    
    
     CargoRepository
{
 
    
    
    
    public
    
    
    
     List SelectByPartCode(
    
    
    
    string
    
    
    
     partCode){}
}
   
   
   
   

当需求又一次变化了，它要从数据库的Cargo表中取出商品名称为“钉子”并且商品编码为“0001”的货物。

这时候问题严重了，看下上面的方法都是一些特定的查询，可能还有很多这样的查询。

他们单个的查询通过组合又形成了新的查询。这就是组合爆炸。

有两种模式可以解决这样的问题：Specification-[Evans的DDD]和Query Object[Fowler,PEAA]，这里只讨论Specification。

在DDD一书中提到：
（原文如下：业务规则不适于放在任何已有实体或值对象中，而且规则的变化和组合会掩盖那些领域对象的基本含义。）
有时经常造成组合爆炸。规格是模型的一部分，将它们从实体或值对象中独立出来有助于使模型更加清晰，它表达的是业务的规则。规格是值对象，它用来判断对象是否满足标准的谓词。谓词是指计算结果为true或false的函数，可以用and、or、not操作符连接。
对规格的接口定义:

public   interface  ISpecification
     {
        bool isSatisfiedBy(object candidate);

        ISpecification and(ISpecification other);
        ISpecification or(ISpecification other);
        ISpecification not();
    }

我们希望具体的规格只实现isSatisfiedBy方法，所以定义抽象类：

   
   
   
   

    
    
    
    public
    
    
    
     
    
    
    
    abstract
    
    
    
     
    
    
    
    class
    
    
    
     AbstractSpecification : ISpecification
    {
        
    
    
    
    #region
    
    
    
     ISpecification 成员
    
    
    
    

        
    
    
    
    public
    
    
    
     
    
    
    
    abstract
    
    
    
     
    
    
    
    bool
    
    
    
     isSatisfiedBy(
    
    
    
    object
    
    
    
     candidate);

        
    
    
    
    public
    
    
    
     ISpecification and(ISpecification other)
        {
            AndSpecification andSpec 
    
    
    
    =
    
    
    
     Singleton
    
    
    
    <
    
    
    
    AndSpecification
    
    
    
    >
    
    
    
    .Instance();
            andSpec.SetAndSpecification(
    
    
    
    this
    
    
    
    , other);
            
    
    
    
    return
    
    
    
     andSpec;
        }

        
    
    
    
    public
    
    
    
     ISpecification or(ISpecification other)
        {
            OrSpecification orSpec 
    
    
    
    =
    
    
    
     Singleton
    
    
    
    <
    
    
    
    OrSpecification
    
    
    
    >
    
    
    
    .Instance();
            orSpec.SetOrSpecification(
    
    
    
    this
    
    
    
    , other);
            
    
    
    
    return
    
    
    
     orSpec;
        }

        
    
    
    
    public
    
    
    
     ISpecification not()
        {
            NotSpecification notSpec 
    
    
    
    =
    
    
    
     Singleton
    
    
    
    <
    
    
    
    NotSpecification
    
    
    
    >
    
    
    
    .Instance();
            notSpec.SetNotSpecification(
    
    
    
    this
    
    
    
    );
            
    
    
    
    return
    
    
    
     notSpec;
        }

        
    
    
    
    #endregion
    
    
    
    
}
   
   
   
   

定义操作符谓词：

internal   class  AndSpecification : AbstractSpecification
     {
        ISpecification one;
        ISpecification other;
        public void SetAndSpecification(ISpecification x, ISpecification y)
        {
            one = x;
            other = y;
        }
        public override bool isSatisfiedBy(object candidate)
        {
            return one.isSatisfiedBy(candidate) && other.isSatisfiedBy(candidate);
        }
    }

internal   class  OrSpecification : AbstractSpecification
     {
        ISpecification one;
        ISpecification other;
        public void SetOrSpecification(ISpecification x, ISpecification y)
        {
            one = x;
            other = y;
        }
        public override bool isSatisfiedBy(object candidate)
        {
            return one.isSatisfiedBy(candidate) || other.isSatisfiedBy(candidate);
        }
    }

internal   class  NotSpecification : AbstractSpecification
     {
        ISpecification wrapped;
        public void SetNotSpecification(ISpecification notSpec)
        {
            wrapped = notSpec;
        }
        public override bool isSatisfiedBy(object candidate)
        {
            return !wrapped.isSatisfiedBy(candidate);
        }
    }

如果使用规格模式，系统中会存在许多小颗粒的规格类。性能会有影响。这里使用享元模式获取规格。

public   class  SpecificationFactory
     {
        private static readonly SpecificationFactory instance = new SpecificationFactory();
        private Dictionary<string, ISpecification> m_SpecList;

        private SpecificationFactory() { }

        public static SpecificationFactory Instance()
        {
            return instance;
        }

        public ISpecification GetSepcification(string assembly,string type)
        {
            ISpecification spec;
            if (m_SpecList==null) { m_SpecList = new Dictionary<string, ISpecification>(); }
            string key = assembly + type;
            if (!m_SpecList.ContainsKey(key))
            {
                spec = Assembly.Load(assembly).CreateInstance(type) as ISpecification;
                if (spec!=null) { m_SpecList.Add(key, spec); return spec; }
                throw new Exception(type + "规格不存在,请确保存" + assembly + "中存在" + type + "类");
            }
            return m_SpecList[key];
        }
    }

这里简单的测试:

[TestMethod]
         public   void  TestSpec()
         {
            SpecificationFactory sf = SpecificationFactory.Instance();
            Cargo cargo=null;
            ISpecification spec = sf.GetSepcification("Bmrxntfj", "Bmrxntfj.Specification.NullSpecification");
            Assert.AreEqual(true, spec.isSatisfiedBy(cargo));
            spec=spec.or(new EqualSpecification());
            Assert.AreEqual(true, spec.isSatisfiedBy(cargo));
            cargo = new Cargo();
            cargo.PartCode = 2;
            cargo.PartName = "2";
            Assert.AreEqual(false, spec.isSatisfiedBy(cargo));
        }

然而我们却不常这样做。因为有些ORM框架采用对象的属性来查询。在基础结构层中生成SQL，这样我们就不需要这样麻烦了。