ASP.NET Core中的依赖注入（5）: ServiceProvider实现揭秘 【解读ServiceCallSite 】

通过上一篇的介绍我们应该对实现在ServiceProvider的总体设计有了一个大致的了解，但是我们刻意回避一个重要的话题，即服务实例最终究竟是采用何种方式提供出来的。ServiceProvider最终采用何种方式提供我们所需的服务实例取决于最终选择了怎样的ServiceCallSite，而服务注册是采用的ServiceDescriptor有决定了ServiceCallSite类型的选择。我们将众多不同类型的ServiceCallSite大体分成两组，一组用来创建最终的服务实例，另一类则与生命周期的管理有关。

一、用于服务创建的ServiceCallSite

服务实例的创建方式主要有三种，分别对应ServiceDescriptor如下三个只读属性。简单来说，如果ImplementationInstance属性返回一个具体的对象，该对象将直接作为提供的服务实例。如果属性ImplementationFactory返回一个具体的委托对象，该委托将会作为提供服务实例的工厂。除此之外，ServiceProvider将会利用ImplementationType属性返回的真是服务类型定位某一个最佳的构造函数来创建最终提供的服务实例。

public class ServiceDescriptor
{
    public Type                               ImplementationType {  get; }
    public object                             ImplementationInstance {  get; }
    public Func<IServiceProvider, object>     ImplementationFactory {  get; }
}

服务实例的这三种不同的创建方式最终由三种对应的ServiceCallSite类型来完成，我们将它们的类型分别命名为InstanceCallSite、FactoryCallSite和ConstructorCallSite。如下面的代码片段所示，前两种ServiceCallSite（InstanceCallSite和FactoryCallSite）的实现非常简单，所以我们在这里就不对它们多做介绍了。

internal class InstanceCallSite : IServiceCallSite
{
public object Instance { get; private set; }

    public InstanceCallSite(object instance)
    {
        this.Instance = instance;
    }
    public Expression Build(Expression provider)
    {
        return Expression.Constant(this.Instance);
    }
    public object Invoke(ServiceProvider provider)
    {
        return Instance;
    }
}

internal class FactoryCallSite : IServiceCallSite
{
    public Func<IServiceProvider, object> Factory { get; private set; }
    public FactoryCallSite(Func<IServiceProvider, object> factory)
    {
        this.Factory = factory;
    }
    public Expression Build(Expression provider)
    {
        Expression<Func<IServiceProvider, object>> factory = p => this.Factory(p);
        return Expression.Invoke(factory, provider);
    }
    public object Invoke(ServiceProvider provider)
    {
        return this.Factory(provider);
    }
}

以执行指定构造函数创建服务实例的ConstructorCallSite稍微复杂一点。如下面的代码片段所示，我们在创建一个ConstructorCallSite对象的时候除了指定一个代表构造函数的ConstructorInfo对象之外，还需要指定一组用于初始化对应参数列表的ServiceCallSite。

internal class ConstructorCallSite : IServiceCallSite
{
    public ConstructorInfo ConstructorInfo { get; private set; }
    public IServiceCallSite[] Parameters { get; private set; }

    public ConstructorCallSite(ConstructorInfo constructorInfo, IServiceCallSite[] parameters)
    {
        this.ConstructorInfo = constructorInfo;
        this.Parameters = parameters;
    }

    public Expression Build(Expression provider)
    {
        ParameterInfo[] parameters = this.ConstructorInfo.GetParameters();
        return Expression.New(this.ConstructorInfo, this.Parameters.Select((p, index) => Expression.Convert(p.Build(provider),
            parameters[index].ParameterType)).ToArray());
    }

    public object Invoke(ServiceProvider provider)
    {
        return this.ConstructorInfo.Invoke(this.Parameters.Select(p => p.Invoke(provider)).ToArray());
    }
}

虽然ConstructorCallSite自身创建服务实例的逻辑很简单，但是如何创建ConstructorCallSite对象本身相对麻烦一些，因为这涉及到如何选择一个最终构造函数的问题。我们在上面专门介绍过这个问题，并且总结出选择构造函数采用的两条基本的策略：

• ServiceProvider能够提供构造函数的所有参数。
• 目标构造函数的参数类型集合是所有有效构造函数参数类型集合的超级。

我们将ConstructorCallSite的创建定义在Service类的CreateConstructorCallSite方法中，它具有额外两个辅助方法GetConstructor和GetParameterCallSites，前者用于选择正确的构造函数，后者则为指定的构造函数创建用于初始化参数的ServiceCallSite列表。

internal class Service : IService
{
    private ConstructorCallSite CreateConstructorCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
    {
        ConstructorInfo constructor = this.GetConstructor(provider, callSiteChain);
        if (null == constructor)
        {
            throw new InvalidOperationException("No avaliable constructor");
        }
        return new ConstructorCallSite(constructor, constructor.GetParameters().Select(p => provider.GetServiceCallSite(p.ParameterType, callSiteChain)).ToArray());
}

    private ConstructorInfo GetConstructor(ServiceProvider provider, ISet<Type> callSiteChain)
    {
        ConstructorInfo[] constructors = this.ServiceDescriptor.ImplementationType.GetConstructors()
            .Where(c => (null != this.GetParameterCallSites(c, provider, callSiteChain))).ToArray();

        Type[] allParameterTypes = constructors.SelectMany(
            c => c.GetParameters().Select(p => p.ParameterType)).Distinct().ToArray();

        return constructors.FirstOrDefault(
            c => new HashSet<Type>(c.GetParameters().Select(p => p.ParameterType)).IsSupersetOf(allParameterTypes));
    }

    private IServiceCallSite[] GetParameterCallSites(ConstructorInfo constructor,ServiceProvider provider,ISet<Type> callSiteChain)
    {
        ParameterInfo[] parameters = constructor.GetParameters();
        IServiceCallSite[] serviceCallSites = new IServiceCallSite[parameters.Length];

        for (int index = 0; index < serviceCallSites.Length; index++)
        {
            ParameterInfo parameter = parameters[index];
            IServiceCallSite serviceCallSite = provider.GetServiceCallSite(
                parameter.ParameterType, callSiteChain);
            if (null == serviceCallSite && parameter.HasDefaultValue)
            {
                serviceCallSite = new InstanceCallSite(parameter.DefaultValue);
            }
            if (null == serviceCallSite)
            {
                return null;
            }
            serviceCallSites[index] = serviceCallSite;
        }
        return serviceCallSites;
    }
    //其他成员
}

二、用于管理生命周期的ServiceCallSite

服务实例最终采用何种提供方式还与服务注册时采用的生命周期管理模式有关，三种不同的生命周期管理模式（Transient、Scoped和Singleton）分别对应着三种不同的ServiceCallSite类型，我们分别将其命名为TransienCallSite、ScopedCallSite和SingletonCallSite。

对于TransientCallSite来说，它提供服务实例的方式非常直接，那就是直接创建一个新的对象。在此之外还需要考虑一个关于服务回收的问题，那就是如果服务实例对应的类型实现了IDisposable接口，需要将它添加到ServiceProvider的TransientDisposableServices属性中。TransientCallSite具有如下的定义，只读属性ServiceCallSite表示真正用于创建服务实例的ServiceCallSite。

internal class TransientCallSite : IServiceCallSite
{
    public IServiceCallSite ServiceCallSite { get; private set; }
    public TransientCallSite(IServiceCallSite serviceCallSite)
    {
        this.ServiceCallSite = serviceCallSite;
    }

    public  Expression Build(Expression provider)
    {
        return Expression.Call(provider, "CaptureDisposable", null, this.ServiceCallSite.Build(provider));
    }

    public  object Invoke(ServiceProvider provider)
    {
        return provider.CaptureDisposable(this.ServiceCallSite.Invoke(provider));
    }
}

internal class ServiceProvider : IServiceProvider, IDisposable
{

    public object CaptureDisposable(object instance)
    {
        IDisposable disposable = instance as IDisposable;
        if (null != disposable)
        {
            this.TransientDisposableServices.Add(disposable);
        }
        return instance;
    }
    //其他成员
}

ScopedCallSite在提供服务实例的时候需要考虑当前ServiceProvider的ResolvedServices属性中是否已经存在已经提供的服务实例，如果已经存在它就无需重复创建。新创建的服务实例需要添加到当前ServiceProvider的ResolvedServices属性中。ScopedCallSite定义如下，ServiceCallSite属性依然表示的是真正用于创建服务实力的ServiceCallSite，Service属性则用来获取保存在当前ServiceProvider的ResolvedServices属性中的服务实例。

internal class ScopedCallSite : IServiceCallSite
{
    public IService Service { get; private set; }
    public IServiceCallSite ServiceCallSite { get; private set; }

    public ScopedCallSite(IService service, IServiceCallSite serviceCallSite)
    {
        this.Service = service;
        this.ServiceCallSite = serviceCallSite;
    }

    public virtual Expression Build(Expression provider)
    {
        var service = Expression.Constant(this.Service);
        var instance = Expression.Variable(typeof(object), "instance");
        var resolvedServices = Expression.Property(provider, "ResolvedServices");
        var tryGetValue = Expression.Call(resolvedServices, "TryGetValue", null, service, instance);
        var index = Expression.MakeIndex(resolvedServices, typeof(ConcurrentDictionary<IService, object>).GetProperty("Item"), new Expression[] { service});
        var assign = Expression.Assign(index, this.ServiceCallSite.Build(provider));

        return Expression.Block(typeof(object),new[] { instance },Expression.IfThen(Expression.Not(tryGetValue),assign),index);
    }

    public virtual object Invoke(ServiceProvider provider)
    {
        object instance;
        return provider.ResolvedServices.TryGetValue(this.Service, out instance)
            ? instance
            : provider.ResolvedServices[this.Service] = this.ServiceCallSite.Invoke(provider);
    }
}

其实Singleton和Scope这两种模式本质上是等同的，它们表示在某个ServiceScope中的“单例”模式，它们之间的不同之处在于前者的ServiceScope是针对作为根的ServiceProvider，后者则是针对当前ServiceProvider。所以SingletonCallSite是ScopedCallSite的派生类，具体定义如下所示。

internal class SingletonCallSite : ScopedCallSite
{
    public SingletonCallSite(IService service, IServiceCallSite serviceCallSite) :
    base(service, serviceCallSite)
    { }

    public override Expression Build(Expression provider)
    {
        return base.Build(Expression.Property(provider, "Root"));
    }

    public override object Invoke(ServiceProvider provider)
    {
        return base.Invoke(provider.Root);
    }
}

三、创建ServiceCallSite

ServiceCallSite的创建体现在IService接口的CreateServiceSite方法中，在我们的Service类这个方法是如何实现的呢？如下面的代码片段所示，真正用于创建服务实例的ServiceCallSite先根据当前的ServiceDescriptor创建出来，然后再根据采用生命周期管理模式创建出与之匹配的ServiceCallSite。

internal class Service : IService
{
    public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
    {
        IServiceCallSite serviceCallSite =
            (null != this.ServiceDescriptor.ImplementationInstance)
            ? new InstanceCallSite(this.ServiceDescriptor.ImplementationInstance)
            : null;

        serviceCallSite = serviceCallSite??
            ((null != this.ServiceDescriptor.ImplementationFactory)
            ? new FactoryCallSite(this.ServiceDescriptor.ImplementationFactory)
            : null);

        serviceCallSite = serviceCallSite ?? this.CreateConstructorCallSite(provider, callSiteChain);

        switch (this.Lifetime)
        {
            case ServiceLifetime.Transient: return new TransientCallSite(serviceCallSite);
            case ServiceLifetime.Scoped: return new ScopedCallSite(this, serviceCallSite);
            default: return new SingletonCallSite(this, serviceCallSite);
        }
    }
    //其他成员
}

ASP.NET Core中的依赖注入（1）：控制反转（IoC）
ASP.NET Core中的依赖注入（2）：依赖注入（DI）
ASP.NET Core中的依赖注入（3）：服务注册与提取
ASP.NET Core中的依赖注入（4）：构造函数的选择与生命周期管理
ASP.NET Core中的依赖注入（5）：ServicePrvider实现揭秘【总体设计】
ASP.NET Core中的依赖注入（5）：ServicePrvider实现揭秘【解读ServiceCallSite】
ASP.NET Core中的依赖注入（5）：ServicePrvider实现揭秘【补充漏掉的细节】