趣味编程:C#中Specification模式的实现

今天有朋友在问了我这么一个问题:怎么实现OrWhere的功能?我猜测,他的意思是要实现这样的功能:

static IEnumerable<int> MorePredicate(IEnumerable<int> source)
{
    return source.OrWhere(i => i > 0); // 或所有的正数
}

static void Main(string[] args)
{
    var array = Enumerable.Range(-5, 10).ToArray();
    var odd = array.Where(i => i % 2 != 0);  // 排除所有偶数
    var oddOrPositive = MorePredicate(odd);

    foreach (var i in oddOrPositive)
    {
        Console.WriteLine(i);
    }
}

以上代码应该输出-5,-3,-1,1,2,3,4。但显然,这段代码是无法编译通过,无法通过补充类库来实现的。因为在Main方法中的Where过后,已经排除了所有的偶数,于是在接下来的代码中是无法从新的序列中再次恢复元素的。

不过这个要求让我想起了Specification模式。Specification模式的作用是构建可以自由组装的业务逻辑元素。Specification类有一个IsSatisifiedBy函数,用于校验某个对象是否满足该Specification所表示的条件。多个Specification对象可以组装起来,并生成新Specification对象,这便可以形成高度可定制的业务逻辑。例如,我们可以使用依赖注入(控制反转)的方式来配置这个业务逻辑,以此保证系统的灵活性。

如果您点开上面那个Wikipedia的链接,就会发现这段描述大约是一个英译中的练习。抄完了“定义”,再来看看同样引自Wikipedia的UML图:

一般来说,Specification模式则意味着实现这样一个接口:

public interface ISpecification
{
    bool IsSatisfiedBy(T candidate);

    ISpecification And(ISpecification other);

    ISpecification Or(ISpecification other);

    ISpecification Not();
}

实现了ISpecification的对象则意味着是一个Specification,它可以通过与其他Specification对象的And,Or或对自身的取反来生成新的逻辑。为了方便这些“组合逻辑”的开发,我们还会准备一个抽象的CompositeSpecification类:

public abstract class CompositeSpecification : ISpecification
{
    public abstract bool IsSatisfiedBy(T candidate);

    public ISpecification And(ISpecification other)
    {
        return new AndSpecification(this, other);
    }

    public ISpecification Or(ISpecification other)
    {
        return new OrSpecification(this, other);
    }

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

CompositeSpecification提供了构建复合Specification的基础逻辑,它提供了And、Or和Not方法的实现,让其他Specification类只需要专注于IsSatisfiedBy方法的实现即可。例如,以下便是三种逻辑组合的具体实现:

public class AndSpecification : CompositeSpecification
{
    private ISpecification m_one;
    private ISpecification m_other;

    public AndSpecification(ISpecification x, ISpecification y)
    {
        m_one = x;
        m_other = y;
    }

    public override bool IsSatisfiedBy(T candidate)
    {
        return m_one.IsSatisfiedBy(candidate) && m_other.IsSatisfiedBy(candidate);
    }
}

public class OrSpecification : CompositeSpecification
{
    private ISpecification m_one;
    private ISpecification m_other;

    public OrSpecification(ISpecification x, ISpecification y)
    {
        m_one = x;
        m_other = y;
    }

    public override bool IsSatisfiedBy(T candidate)
    {
        return m_one.IsSatisfiedBy(candidate) || m_other.IsSatisfiedBy(candidate);
    }
}

public class NotSpecification : CompositeSpecification
{
    private ISpecification m_wrapped;

    public NotSpecification(ISpecification x)
    {
        m_wrapped = x;
    }

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

于是,我们便可以使用Specification模式来处理刚才那位朋友的问题。例如,首先他需要排除所有的偶数,那么我们不妨实现一个OddSpecification:

public class OddSpecification : CompositeSpecification<int>
{
    public override bool IsSatisfiedBy(int candidate)
    {
        return candidate % 2 != 0;
    }
}

自然,还有用于获得所有正数的Specification类:

public class PositiveSpecification : CompositeSpecification<int>
{
    public override bool IsSatisfiedBy(int candidate)
    {
        return candidate > 0;
    }
}

于是在使用时,我们会将其通过Or方法组合起来:

static ISpecification<int> MorePredicate(ISpecification<int> original)
{
    return original.Or(new PositiveSpecification());
}

static void Main(string[] args)
{
    var array = Enumerable.Range(-5, 10).ToArray();
    var oddSpec = new OddSpecification();
    var oddAndPositiveSpec = MorePredicate(oddSpec);

    foreach (var item in array.Where(i => oddAndPositiveSpec.IsSatisfiedBy(i)))
    {
        Console.WriteLine(item);
    }
}

但是,您觉得这个做法怎么样?我觉得过于杀鸡用牛刀,高射炮打蚊子了。Specification模式虽然常用,但是用在这里太重量级了。如果我们为每一个函数都补充一个Specification类,至少会让我感到厌倦。

以上的代码其实转载自Wikipedia词条,不过我修改了一些命名,以及改写成泛型版本。我们有理由推测,Wikipedia上是非常旧的内容,很可能是在C#只是1.0版本的时候编写的代码(或者说它为了“兼容”Java那种语言的实现方式)。那么在实际开发过程中,我们又该如何利用C#如今的强大特性来实现出更容易使用,甚至是更为“轻量级”的Specification模式呢?

此外,刚才又收到那位朋友的消息,他其实是想在使用LINQ to SQL时实现“可扩展的逻辑”。那么,对于他说的情况,我们又该如何应对呢?

你可能感兴趣的:(趣味编程:C#中Specification模式的实现)