设计原则：不要为了复用而使用继承

背景

今天上午和以为朋友聊了一个设计问题：如何消除仓库相关的单据的Repository中的重复逻辑？如：入库单Repository和出库单Repository之间的重复。可以有很多方式消除重复，在不同级别消除重复，如：继承、组合、掺入、帮助类、帮助方法。本文只说出我的观点：不要为了复用而使用继承。

为什么要得出这个结论：在单实现继承模型下，你复用了一个基类的实现，就不能复用其它基类的实现了，接口继承 + 扩展类型（Mixin）可以很好的解决这个问题。 

设计的演化

下面我会演示：待重构的重复代码-》用继承消除重复-》用扩展类（Mixin）消除重复-》Ruby的鸭子类型 + Mixin的实现（元编程可以更牛叉，有机会再说）。

待重构的代码

注意：出库单仓储和入库单仓储的“根据编号获取单据”重复了。

类图

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Linq.Expressions;

namespace CSharpStudy.MixinStudy.V1
{
    class Aggregate { }

    interface IRepository<T> where T : Aggregate
    {
        IEnumerable<T> Where(Expression<Func<T, bool>> condition);
    }

    class Repository<T> : IRepository<T>
        where T : Aggregate
    {
        public IEnumerable<T> Where(Expression<Func<T, bool>> condition)
        {
            throw new NotImplementedException();
        }
    }

    class 入库单 : Aggregate
    {
        public string 单据编号 { get; set; }
    }

    class 出库单 : Aggregate
    {

用继承消除重复

当我看到上面的重复代码的时候，第一印象是引入两个基类：仓库单据基类和仓库单据仓储基类。

类图

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Linq.Expressions;

namespace CSharpStudy.MixinStudy.V2
{
    class Aggregate { }

    interface IRepository<T> where T : Aggregate
    {
        IEnumerable<T> Where(Expression<Func<T, bool>> condition);
    }

    class Repository<T> : IRepository<T>
        where T : Aggregate
    {
        public IEnumerable<T> Where(Expression<Func<T, bool>> condition)
        {
            throw new NotImplementedException();
        }
    }

    class 仓库单据基类 : Aggregate
    {
        public string 单据编号 { get; set; }
    }

    class 入库单 : 仓库单据基类 { }

    class 出库单 : 仓库单据基类 { }

    class 仓库单据仓储基类<T> : Repository<T>
        where T : 仓库单据基类
    {
        public IEnumerable<T> 根据编号获取单据(string 单据编号)
        {
            return this.Where(x => x.单据编号 == 单据编号);
        }
    }

    class 入库单仓储 : 仓库单据仓储基类<入库单> { }

    class 出库单仓储 : 仓库单据仓储基类<出库单> { }
}

用扩展类（Mixin）消除重复

我对了吗？没有多态，只是为了复用就引入继承，是否合理呢？

类图

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Linq.Expressions;

namespace CSharpStudy.MixinStudy.V3
{
    class Aggregate { }

    interface IRepository<T> where T : Aggregate
    {
        IEnumerable<T> Where(Expression<Func<T, bool>> condition);
    }

    class Repository<T> : IRepository<T>
        where T : Aggregate
    {
        public IEnumerable<T> Where(Expression<Func<T, bool>> condition)
        {
            throw new NotImplementedException();
        }
    }

    class 仓库单据基类 : Aggregate
    {
        public string 单据编号 { get; set; }
    }

    class 入库单 : 仓库单据基类 { }

    class 出库单 : 仓库单据基类 { }

    static class 仓库单据基类仓储扩展
    {
        public static IEnumerable<T> 根据编号获取单据<T>(this IRepository<T> that, string 单据编号)
            where T : 仓库单据基类
        {
            return that.Where(x => x.单据编号 == 单据编号);
        }
    }
}

Ruby的鸭子类型 + Mixin的实现

代码

# coding: utf-8

class Aggregate
end

class Repository
    def Where(condition)
    end
end

class C仓库单据基类 < Repository
    attr_accessor :单据编号
end

class C入库单 < C仓库单据基类
end

class C出库单 < C仓库单据基类
end

module C仓库单据基类仓储扩展
    def 根据编号获取单据(单据编号)
        return self.Where({:单据编号 => 单据编号})
    end
end

class C入库单仓储 < Repository
    include C仓库单据基类仓储扩展
end

class C出库单仓储 < Repository
    include C仓库单据基类仓储扩展
end

Ruby正统的支持了Mixin，鸭子类型天生具备泛型的特点，比泛型强大，元编程更是牛叉（本文没有体现）。

备注

 做一件事如果只有一个选择，就说明有问题了，多思考几个方案，折中后考虑一个方案。