如何编写一个简单的依赖注入容器

随着大规模的项目越来越多，许多项目都引入了依赖注入框架，其中最流行的有Castle Windsor, Autofac和Unity Container。
微软在最新版的Asp.Net Core中自带了依赖注入的功能，有兴趣可以查看这里。
关于什么是依赖注入容器网上已经有很多的文章介绍，这里我将重点讲述如何实现一个自己的容器，可以帮助你理解依赖注入的原理。

容器的构想

在编写容器之前，应该先想好这个容器如何使用。
容器允许注册服务和实现类型，允许从服务类型得出服务的实例，它的使用代码应该像

var container = new Container();

container.Register();

var logger = container.Resolve();

最基础的容器

在上面的构想中，Container类有两个函数，一个是Register，一个是Resolve。
容器需要在Register时关联ILogger接口到MyLogger实现，并且需要在Resolve时知道应该为ILogger生成MyLogger的实例。
以下是实现这两个函数最基础的代码

public class Container
{
    // service => implementation
    private IDictionary TypeMapping { get; set; }

    public Container()
    {
        TypeMapping = new Dictionary();
    }

    public void Register()
        where TImplementation : TService
    {
        TypeMapping[typeof(TService)] = typeof(TImplementation);
    }

    public TService Resolve()
    {
        var implementationType = TypeMapping[typeof(TService)];
        return (TService)Activator.CreateInstance(implementationType);
    }
}

Container在内部创建了一个服务类型(接口类型)到实现类型的索引，Resolve时使用索引找到实现类型并创建实例。
这个实现很简单，但是有很多问题，例如

• 一个服务类型不能对应多个实现类型
• 没有对实例进行生命周期管理
• 没有实现构造函数注入

改进容器的构想 - 类型索引类型

要让一个服务类型对应多个实现类型，可以把TypeMapping改为

IDictionary> TypeMapping { get; set; }

如果另外提供一个保存实例的变量，也能实现生命周期管理，但显得稍微复杂了。
这里可以转换一下思路，把{服务类型=>实现类型}改为{服务类型=>工厂函数}，让生命周期的管理在工厂函数中实现。

IDictionary>> Factories { get; set; }

有时候我们会想让用户在配置文件中切换实现类型，这时如果把键类型改成服务类型+字符串，实现起来会简单很多。
Resolve可以这样用: Resolve(serviceKey: Configuration["ImplementationName"])

IDictionary, IList>> Factories { get; set; }

改进容器的构想 - Register和Resolve的处理

在确定了索引类型后，Register和Resolve的处理都应该随之改变。
Register注册时应该首先根据实现类型生成工厂函数，再把工厂函数加到服务类型对应的列表中。
Resolve解决时应该根据服务类型找到工厂函数，然后执行工厂函数返回实例。

改进后的容器

这个容器新增了一个ResolveMany函数，用于解决多个实例。
另外还用了Expression.Lambda编译工厂函数，生成效率会比Activator.CreateInstance快数十倍。

public class Container
{
    private IDictionary, IList>> Factories { get; set; }

    public Container()
    {
        Factories = new Dictionary, IList>>();
    }

    public void Register(string serviceKey = null)
        where TImplementation : TService
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            factories = new List>();
            Factories[key] = factories;
        }
        var factory = Expression.Lambda>(Expression.New(typeof(TImplementation))).Compile();
        factories.Add(factory);
    }

    public TService Resolve(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        var factory = Factories[key].Single();
        return (TService)factory();
    }

    public IEnumerable ResolveMany(string serviceKey = null)
    {
        var key = Tuple.Create(typeof(TService), serviceKey);
        IList> factories;
        if (!Factories.TryGetValue(key, out factories))
        {
            yield break;
        }
        foreach (var factory in factories)
        {
            yield return (TService)factory();
        }
    }
}

改进后的容器仍然有以下的问题

• 没有对实例进行生命周期管理
• 没有实现构造函数注入

实现实例的单例

以下面代码为例

var logger_a = container.Resolve();
var logger_b = container.Resolve();

使用上面的容器执行这段代码时，logger_a和logger_b是两个不同的对象，如果想要每次Resolve都返回同样的对象呢？
我们可以对工厂函数进行包装，借助闭包(Closure)的力量可以非常简单的实现。

private Func