為了讓讀者朋友們能夠對.NET Core DI框架的實現原理具有一個深刻而認識，我們採用與之類似的設計構架了一個名為Cat的DI框架。在《依賴注入[4]: 建立一個簡易版的DI框架[上篇]》中我們介紹了Cat的基本程式設計模式，接下來我們就來聊聊Cat的設計和實現。

目錄
一、服務註冊：ServiceRegistry
二、DI容器：Cat
三、擴充套件方法

一、服務註冊：ServiceRegistry

由於作為DI容器的Cat物件總是利用預先新增到服務註冊來提供對應的服務例項，所以服務註冊至關重要。如下所示的就是表示服務註冊的ServiceRegistry的定義，它具有三個核心屬性（ServiceType、Lifetime和Factory）分別代表服務型別、生命週期模式和用來建立服務例項的工廠。最終用來建立服務例項的工廠體現為一個型別為Func<Cat,Type[], object>的委託物件，它具有的兩個輸入分別代表當前使用的Cat物件以及提供服務型別的泛型引數列表

，如果提供的服務型別並不是一個泛型型別，這個引數會指定為空的型別陣列。

public class ServiceRegistry
{
    public Type                         ServiceType { get; }
    public Lifetime                     Lifetime { get; }
    public Func<Cat,Type[], object>    Factory { get; }
    internal ServiceRegistry            Next { get; set
 
; }
    public ServiceRegistry(Type serviceType, Lifetime lifetime, Func<Cat,Type[], object> factory)
    {
        ServiceType     = serviceType;
        Lifetime        = lifetime;
        Factory         = factory;
    }
    internal IEnumerable<ServiceRegistry> AsEnumerable()
    {
        
 
var list = new List<ServiceRegistry>();
        for (var self = this; self!=null; self= self.Next)
        {
            list.Add(self);
        }
        return list;
    }
}

我們將針對同一個服務型別（ServiceType屬性相同）的多個ServiceRegistry組成一個連結串列，作為相鄰節點的兩個ServiceRegistry物件通過Next屬性關聯起來。我們為ServiceRegistry定義了一個AsEnumerable方法是它返回由當前以及後續節點組成的ServiceRegistry集合。如果當前ServiceRegistry為連結串列表頭，那麼這個方法返回連結串列所有的節點。

二、DI容器：Cat

在瞭解了表示服務註冊的ServiceRegistry之後，我們來著重介紹表示DI容器的Cat型別。如下面的程式碼片段所示，Cat同時實現了IServiceProvider和IDisposable介面，定義在前者中的GetService用於提供最終的服務例項。作為根容器的Cat物件通過公共建構函式建立，另一個內部建構函式則用來建立作為子容器的Cat物件，指定的Cat物件將作為父容器。

public class Cat : IServiceProvider, IDisposable
{
    internal Cat                                         _root;
    internal ConcurrentDictionary<Type, ServiceRegistry>     _registries;
    private ConcurrentDictionary<ServiceRegistry, object>    _services;
    private ConcurrentBag<IDisposable>                      _disposables;
    private volatile bool                                 _disposed;
    public Cat()
    {
        _registries   = new ConcurrentDictionary<Type, ServiceRegistry>();
        _root         = this;
        _services     = new ConcurrentDictionary<ServiceRegistry, object>();
        _disposables  = new ConcurrentBag<IDisposable>();
    }
    internal Cat(Cat parent)
    {
        _root         = parent._root;
        _registries   = _root._registries;
        _services     = new ConcurrentDictionary<ServiceRegistry, object>();
        _disposables  = new ConcurrentBag<IDisposable>();
    }
    private void EnsureNotDisposed()
    {
        if (_disposed)
        {
            throw new ObjectDisposedException("Cat");
        }
    }  
    ...
}

作為根容器的Cat物件通過_root欄位表示。_registries欄位返回的一個ConcurrentDictionary<Type, ServiceRegistry>物件表示所有新增的服務註冊，字典物件的Key和Value分別表示服務型別和ServiceRegistry連結串列。由當前Cat物件提供的非Transient服務例項儲存在由_services欄位表示的一個ConcurrentDictionary<ServiceRegistry, object>物件上，該字典物件的Key表示建立服務例項所使用的ServiceRegistry物件。由於需要負責完成對提供服務例項的釋放工作，所以我們需要將實現了IDisposable介面的服務例項儲存在通過_disposables欄位表示的集合中。

雖然我們為Cat定義了若干擴充套件方法來提供多種不同的服務註冊，但是這些方法最終都會呼叫如下這個Register方法，該方法會將提供的ServiceRegistry新增到_registries欄位表示的字典物件中。值得注意的是，不論我們是呼叫那個Cat物件的Register方法，指定的ServiceRegistry都會被新增到作為根容器的Cat物件上。

public class Cat : IServiceProvider, IDisposable
{
    public Cat Register(ServiceRegistry registry)
    {
        EnsureNotDisposed();
        if (_registries.TryGetValue(registry.ServiceType, out var existing))
        {
            _registries[registry.ServiceType] = registry;
            registry.Next = existing;
        }
        else
        {
            _registries[registry.ServiceType] = registry;
        }
        return this;
}
...
}

用來提供服務例項的核心操作實現在如下這個GetServiceCore方法中。如下面的程式碼片段所示，我們在呼叫該方法的時候需要指定對應的ServiceRegistry和服務物件泛型引數。當該方法被執行的時候，對於Transient生命週期模式，它會直接利用ServiceRegistry提供的工廠來建立服務例項，如果服務例項實現了IDisposable介面，它會被新增到_disposables欄位表示的待釋放服務例項列表中。對於Root和Self生命週期模式，該方法會先根據提供的ServiceRegistry判斷是否對應的服務例項已經存在，存在的服務例項會直接作為返回值。

public class Cat : IServiceProvider, IDisposable
{
    private object GetServiceCore(ServiceRegistry registry, Type[] genericArguments)
    {
        var serviceType = registry.ServiceType;
        object GetOrCreate(ConcurrentDictionary<ServiceRegistry, object> services, ConcurrentBag<IDisposable> disposables)
        {
            if (services.TryGetValue(registry, out var service))
            {
                return service;
            }
            service = registry.Factory(this, genericArguments);
            services[registry] = service;
            var disposable = service as IDisposable;
            if (null != disposable)
            {
                disposables.Add(disposable);
            }
            return service;
        }
        switch (registry.Lifetime)
        {
            case Lifetime.Root: return GetOrCreate(_root._services, _root._disposables);   
            case Lifetime.Self: return GetOrCreate(_services, _disposables);
            default:
                {
                    var service = registry.Factory(this, genericArguments);
                    var disposable = service as IDisposable;
                    if (null != disposable)
                    {
                        _disposables.Add(disposable);
                    }
                    return service;
                }
        }
    }
}

GetServiceCore方法只有在指定ServiceRegistry對應的服務例項不存在的情況下采用利用提供的工廠來建立服務例項，建立的服務例項會根據生命週期模式儲存到作為根容器的Cat物件或者當前Cat物件上。如果提供的服務例項實現了IDisposable介面，在採用Root生命週期模式下會被儲存到作為根容器的Cat物件的待釋放列表中，如果生命週期模式為Self，它會被新增到當前Cat物件的待釋放列表中。

在實現的GetService方法中，Cat會根據指定的服務型別找到對應的ServiceRegistry物件，並最終呼叫GetServiceCore方法來提供對應的服務例項。GetService方法會解決一些特殊服務提供問題，如果服務型別為Cat或者IServiceProvider，該方法返回的就是它自己。如果服務型別為IEnumerable<T>，GetService會根據泛型引數型別T找到所有的ServiceRegistry並利用它們來建立對應的服務例項，最終返回的是有這些服務例項組成的集合。除了這些，針對泛型服務例項的提供也是在這個方法中解決的。

public class Cat : IServiceProvider, IDisposable
{
    public object GetService(Type serviceType)
    {
        EnsureNotDisposed();
        if (serviceType == typeof(Cat) || serviceType == typeof(IServiceProvider))
        {
            return this;
        }
        ServiceRegistry registry;
        if (serviceType.IsGenericType && serviceType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        {
            var elementType = serviceType.GetGenericArguments()[0];
            if (!_registries.TryGetValue(elementType, out  registry))
            {
                return Array.CreateInstance(elementType, 0);
            }
            var registries = registry.AsEnumerable();
            var services = registries.Select(it => GetServiceCore(it,  new Type[0])).ToArray();
            Array array = Array.CreateInstance(elementType, services.Length);
            services.CopyTo(array, 0);
            return array;
        }
        if (serviceType.IsGenericType && !_registries.ContainsKey(serviceType))
        {
            var definition = serviceType.GetGenericTypeDefinition();
            return _registries.TryGetValue(definition, out registry)
                ? GetServiceCore(registry, serviceType.GetGenericArguments())
                : null;
        }
        return _registries.TryGetValue(serviceType, out registry)
                ? GetServiceCore(registry, new Type[0])
                : null;
    }
    ...
}

在實現的Dispose方法中，由於所有待釋放的服務例項已經儲存到_disposables欄位表示的集合中，所以我們只需要依次呼叫它們的Dispose方法即可。在釋放了所有服務例項並清空待釋放列表後，Dispose方法還會清空_services欄位表示的服務例項列表。

public class Cat : IServiceProvider, IDisposable
{
    public void Dispose()
    {
        _disposed = true;
        foreach(var disposable in _disposables)
        {
            disposable.Dispose();
        }
        while (!_disposables.IsEmpty)
        {
            _disposables.TryTake(out _);
        }
        _services.Clear();
    }
    ...
}

三、擴充套件方法

為了方便註冊服務，我們定義瞭如下三個4個擴充套件方法Register。由於服務註冊的新增總是需要呼叫Cat自身的Register方法來完成，所以這些方法最終都需要建立一個代表服務註冊的ServiceRegistry物件。對於一個ServiceRegistry物件來說，它最為核心的莫過於表示服務例項建立工廠的Func<Cat,Type[], object>物件，所以上述這4個擴充套件方法需要解決的就是建立這麼一個委託物件。

public static class CatExtensions
{
    public static Cat Register(this Cat cat, Type from, Type to, Lifetime lifetime)
    {
        Func<Cat, Type[], object> factory = (_, arguments) => Create(_, to, arguments);
        cat.Register(new ServiceRegistry(from, lifetime, factory));
        return cat;
    }
    public static Cat Register<TFrom, TTo>(this Cat cat, Lifetime lifetime) where TTo:TFrom
        => cat. Register(typeof(TFrom), typeof(TTo), lifetime);
    public static Cat Register<TServiceType>(this Cat cat, TServiceType instance)
    {
        Func<Cat, Type[], object> factory = (_, arguments) => instance;
        cat.Register(new ServiceRegistry(typeof(TServiceType),  Lifetime.Root, factory));
        return cat;
    }
    public static Cat Register<TServiceType>(this Cat cat, Func<Cat,TServiceType> factory, Lifetime lifetime)
    {
        cat.Register(new ServiceRegistry(typeof(TServiceType), lifetime, (_,arguments)=>factory(_)));
        return cat;
    }
    public static bool HasRegistry<T>(this Cat cat) => cat.HasRegistry(typeof(T));
    public static bool HasRegistry(this Cat cat, Type serviceType) => cat._root._registries.ContainsKey(serviceType);
    private static object Create(Cat cat, Type type, Type[] genericArguments)
    {
        if (genericArguments.Length > 0)
        {
            type = type.MakeGenericType(genericArguments);
        }
        var constructors = type.GetConstructors(BindingFlags.Instance);
        if (constructors.Length == 0)
        {
            throw new InvalidOperationException($"Cannot create the instance of 
                {type} which does not have an public constructor."); 
        }
        var constructor = constructors.FirstOrDefault(it => it.GetCustomAttributes(false).OfType<InjectionAttribute>().Any());
        constructor = constructor ?? constructors.First();
        var parameters = constructor.GetParameters();
        if (parameters.Length == 0)
        {
            return Activator.CreateInstance(type);
        }
        var arguments = new object[parameters.Length];
        for (int index = 0; index < arguments.Length; index++)
        {
            var parameter = parameters[index];
            var parameterType = parameter.ParameterType;
            if (cat.HasRegistry(parameterType))
            {
                arguments[index] = cat.GetService(parameterType);
            }
            else if (parameter.HasDefaultValue)
            {
                arguments[index] = parameter.DefaultValue;
            }
            else
            {
                throw new InvalidOperationException($"Cannot create the instance of {type} whose constructor has non-registered parameter type(s)");
            }
        }
        return Activator.CreateInstance(type, arguments);
    }
}

第三個擴充套件方法來指定的是一個用來提供服務例項的Func<Cat,TServiceType>物件，最後一個擴充套件方法指定的直接就是服務例項，所以我們很容易將提供的引數轉換成一個Func<Cat,Type[], object>。由於前兩個過載指定的是服務實現型別，所以我們需要呼叫對應的建構函式來建立服務例項，這一邏輯實現在私有的Create方法中。

我們刻意簡化了建構函式的篩選邏輯。為了解決建構函式的選擇問題，我們引入如下這個InjectionAttribute特性。我們將所有公共例項建構函式作為候選的建構函式，並會優先選擇標註了該特性的建構函式。當建構函式被選擇出來後，我們需要通過分析其引數型別並利用Cat物件來提供具體的引數值，這實際上是一個遞迴的過程。最終我們將針對建構函式的呼叫轉換成Func<Cat,Type[], object>物件，進而創建出表示服務註冊的ServiceRegistry物件。

[AttributeUsage( AttributeTargets.Constructor)]
public class InjectionAttribute: Attribute {}

上面給出的程式碼片段還提供了兩個HasRegistry和HasRegistry<T>方法來確定指定型別的服務註冊是否存在。除此之外，用於提供服務例項的泛型方法GetService<T>和用於提供所有指定型別服務例項的GetService<T>方法採用瞭如下的定義方式。

public static class CatExtensions
{
    public static IEnumerable<T> GetServices<T>(this Cat cat) => cat.GetService<IEnumerable<T>>();
    public static T GetService<T>(this Cat cat) => (T)cat.GetService(typeof(T));
}