Core官方DI解析(5)-ServiceProviderEngine

最后来看看前面一直说的engine(工作引擎)，工作引擎接口是iserviceproviderengine在serviceprovider的构造函数中看到了根据指定的mode创建了不同的实现类,下面先来看一下iserviceproviderengine接口和其实现类的整体结构

iserviceproviderengine类型继承关系

internal interface iserviceproviderengine : idisposable, iserviceprovider
 {
      iservicescope rootscope { get; }
 }

`iserviceprovderengine这个接口`继承了`iserviceprovider`接口,也就是说工作引擎也具有**getservice()**方法,在此接口中具有一个`iservicescope`类型的**rootscope**,而这个属性则代表是**根容器**

`iservicescope`代表一个容器接口,这个接口中具有一个`iserviceprovider`类型的属性,返回真正表示容器的一个`iserviceprovider`类型            

public interface iservicescope : idisposable
{
   /// <summary>
   /// the <see cref="system.iserviceprovider"/> used to resolve dependencies from the scope.
   /// </summary>
   iserviceprovider serviceprovider { get; }
}   

iserviceproviderengine整体结构

iserviceproviderengine

• serviceproviderengine
  • compiledserviceproviderengine
    • dynamicserviceproviderengine
  • runtimeserviceproviderengine
  • ilemitserviceproviderengine
  • expressionsserviceproviderengine

上面是目前整个引擎结构,但是前面说过目前只用到了`dynamicserviceproviderengine`,但是我们看整个类型会看到其实在这几个派生类型中只有一个实现方法`realizeservice(servicecallsite callsite)`,而整体结构都是在基类`serviceproviderengine`类型中,下面来看看这个基类类型

serviceproviderengine

`serviceproviderengine`类型是整个结构的核心类型,但是这个类也是一个很简单的类，这个类只是调用`callsitefactory`和`callsiteruntimeresolver`,由下图可以看到这个类型是一个抽象类,并且实现了`iserviceproviderengine`和`iservicescopefactory`接口接口            

`iservicescopefactory`这个接口提供了一个创建子容器方法我们已知道`iserviceproviderengine`接口*继承*了`iserviceprovider`接口,那么也就是说在`serviceproviderengine`已经具备以下两个功能 

1.获取服务实例对象

2.创建子容器

internal abstract class serviceproviderengine : iserviceproviderengine, iservicescopefactory{}


//      创建子容器接口
public interface iservicescopefactory
{
     //     
     iservicescope createscope();
}

下面首先来看一下此类中拥有的字段+属性，这些属性都是在构造器中进行了实例化

• _callback：

  这个字段就是*容器时检查scoped生命周期的访问者对象，这个从serviceprovider类中时进行传入的，在这里并不细讲这个类型

• realizedservices:

  这个属性是缓存根据容器获取服务实例对象委托,其中key为servicetype

• _createserviceaccessor：

  这是一个根据类型获取一个根据容器获取服务实例对象的委托,可以看到使用了一个createserviceaccessor()进行赋值,createserviceaccessor()是此类型的一个核心方法,下面介绍

• callsitefactory：

  servicecallsite工厂类型，在构造器中实例化，可以看到实例化时将servicedescriptors进行传入，并且可以看到在构造器中向此实例对象中添加了一个iserviceprovider和iservicescopefactory

• runtimeresolver：

  这个属性是是获取服务实例的访问者对象,可以看到在构造器中进行传入

• root：

  root代表是一个*容器serviceproviderenginescope类型则是一个具体的容器类型,这个类型中缓存了所有的具体服务实例对象,这个类型实现了iservicescope接口,从下面代码可以看到rootscope其实就是直接返回了root属性

• rootscope：

  这也是一个根容器实例对象，直接返回的root属性

//      *容器时scoped生命周期实例检查策略   
private readonly iserviceproviderenginecallback _callback;
//      根据类型创建构建服务的委托
private readonly func<type, func<serviceproviderenginescope, object>> _createserviceaccessor;
//      此实例是否被销毁
private bool _disposed;

//      缓存根据容器获取服务实例的委托，  key为注册类型
internal concurrentdictionary<type, func<serviceproviderenginescope, object>> realizedservices { get; }

 //     callsite工厂类属性,此类型用于根据指定实例化方式来创建对应的callsite
internal callsitefactory callsitefactory { get; }
//      访问者对象,此对象对进行实例和缓存具体真正的对象
protected callsiteruntimeresolver runtimeresolver { get; }

//      根容器实例属性
public serviceproviderenginescope root { get; }
//      根容器实例属性
public iservicescope rootscope => root;

//      构造器
protected serviceproviderengine(ienumerable<servicedescriptor> servicedescriptors, iserviceproviderenginecallback callback)
{
     _createserviceaccessor = createserviceaccessor;
     _callback = callback;
     //      实例化根容器
     root = new serviceproviderenginescope(this);
     //      实例化 callsite对象访问者对象
     runtimeresolver = new callsiteruntimeresolver();

     //      实例化callsitefactory类型对象
     callsitefactory = new callsitefactory(servicedescriptors);
     callsitefactory.add(typeof(iserviceprovider), new serviceprovidercallsite());
     //      缓存一个servicescopefactorycallsite服务,相当于缓存一个serviceproviderengine,根据此对象进行创建子容器
     callsitefactory.add(typeof(iservicescopefactory), new servicescopefactorycallsite());
     //     缓存实例化对象的工厂
     realizedservices = new concurrentdictionary<type, func<serviceproviderenginescope, object>>();
}

`serviceproviderengine`类型中方法只有**getservice()**,**createscope()**,**createserviceaccessor()**,**dispose()**和一个抽象方法**realizeservice()**,其中几个派生类中都只是实现了**realizeservice()**,这个一会再看,下面来看看`serviceproviderengine`类中的这几个方法

• realizeservice：

  这个方法由派生类继承，由指定的servicecallsite缓存并获取 服务实例的委托

• getservice：

  这个方法获取服务实例对象，可以看到具有两个此方法，并且第一个调用了第二个，并将*容器root进行了传入，而在第二个方法中，获取并添加**_createserviceaccessor**委托，然后调用此委托进行获取服务实例

• createscope：

  这个方法是创建一个子容器对象，在这个方法中可以看到直接 new 了一个容器对象，并将当前对象进行了传入。从此可以得知为什么所有容器共享*容器的服务注册了

• dispose：

  清除当前对象，并清除*容器

• createserviceaccessor：

  这个方法可以看到根据servicetype进行获取指定servicecallsite,然后再调用派生类实现的realizeservice()进行返回

//      抽象类型,子类实现
protected abstract func<serviceproviderenginescope, object> realizeservice(servicecallsite callsite);

public object getservice(type servicetype) => getservice(servicetype, root);

internal object getservice(type servicetype, serviceproviderenginescope serviceproviderenginescope)
{
     if (_disposed)
        throwhelper.throwobjectdisposedexception();
     //      添加并获取根据容器对象实例化对象的方法,其方法由子类进行重写
     var realizedservice = realizedservices.getoradd(servicetype, _createserviceaccessor);
     //      验证是否允许进行实例化对象
     _callback?.onresolve(servicetype, serviceproviderenginescope);
     return realizedservice.invoke(serviceproviderenginescope);
}
public void dispose()
{
     _disposed = true;
     root.dispose();
}
//      实例化的子容器
public iservicescope createscope()
{
     if (_disposed)
          throwhelper.throwobjectdisposedexception();
     return new serviceproviderenginescope(this);
}
private func<serviceproviderenginescope, object> createserviceaccessor(type servicetype)
{
     //      根据基类类型获取对应的callsite
     var callsite = callsitefactory.getcallsite(servicetype, new callsitechain());
     if (callsite != null)
     {
          //  缓存当前注册
          _callback?.oncreate(callsite);
          return realizeservice(callsite);
     }
     return _ => null;
}

dynamicserviceproviderengine和compiledserviceproviderengine

下面来看一下`dynamicserviceproviderengine`和`compiledserviceproviderengine`这两个派生类型,从上面继承关系可以看到这两个派生类型是一个继承关系 `dynamicserviceproviderengine`继承于`compiledserviceproviderengine`.

internal class dynamicserviceproviderengine : compiledserviceproviderengine{}

​在这两个派生类型中都只是实现了基类的realizeservice(),下面先来看看compiledserviceproviderengine类的实现

可以看到compiledserviceproviderengine类中具有一个expressionresolverbuilder对象,这个类是使用表达式树生成结构,这个实例在构造函数进行创建，并且将callsiteruntimeresolver对象，本对象和*容器进行了传入，可以看到在重写的方法中是调用了expressionresolverbuilder对象的build()，这个方法会生成一个func<serviceproviderenginescope,object>委托，然后缓存此委托，

注：expressionresolverbuilder这个类挺复杂，我也没看懂，所以在此不介绍，有兴趣的可以直接看源码

internal abstract class compiledserviceproviderengine : serviceproviderengine
{
    //      表达式树生成对象
     public expressionresolverbuilder expressionresolverbuilder { get; }
     
     //     构造函数
     public compiledserviceproviderengine(ienumerable<servicedescriptor> servicedescriptors, iserviceproviderenginecallback callback) : base(servicedescriptors, callback)
        => expressionresolverbuilder = new expressionresolverbuilder(runtimeresolver, this, root);
     
     //     重写realizeservice方法
     protected override func<serviceproviderenginescope, object> realizeservice(servicecallsite callsite)
     {
          //      使用表达式树进行创建一个func<serviceproviderenginescope,object>委托
          var realizedservice = expressionresolverbuilder.build(callsite);
          //      直接将表达式生成的委托进行替换之前的缓存
          realizedservices[callsite.servicetype] = realizedservice;
          return realizedservice;
     }
}

而在`runtimeserviceproviderengine`类中，则只是实现了**realizeservice()**，从下面代码可以看出在第一次调用时是直接调用`callsiteruntimeresolver`这个访问者获取的实例数据，而在第二次才调用的基类，也就是`compiledserviceproviderengine`进行了缓存，但是至于为什么这样干，我没有弄清。。。

internal class dynamicserviceproviderengine : compiledserviceproviderengine
{
     public dynamicserviceproviderengine(
     ienumerable<servicedescriptor> servicedescriptors, 
     iserviceproviderenginecallback callback) 
     : base(servicedescriptors, callback)
     {
     }

     protected override func<serviceproviderenginescope, object> realizeservice(servicecallsite callsite)
     {
          var callcount = 0;
          return scope =>
          {
               if (interlocked.increment(ref callcount) == 2)
               {
                    //      如果当前是第二次调用,则调用父级进行缓存
                    task.run(() => base.realizeservice(callsite));
               }
               //      调用访问者进行根据当前容器和callsite进行实例化服务对象
               return runtimeresolver.resolve(callsite, scope);
          };
     }
}