Core官方DI解析(3)-ServiceCallSite.md

上一篇说过在整个di框架中iserviceproviderengine是核心,但是如果直接看iserviceproviderengine派生类其实看不出也没什么东西,因为这个类型其实都是调用的其它对象方法,所以我们先来看看其它的类型

servicecallsite

servicecallsite

​ 这个是一个服务访问配置的类型,di内部使用此类的派生类型进行封装所需要实例化的信息然后进行实例化服务对象,首先我们先来看一下servicecallsite这个类所拥有的属性。从下面可以看到servicecallsite具有三个抽象属性和一个非抽象属性,其中servicetype和implementationtype已经知道代表注册的服务类型和实例对象的类型,

kind是一个callsitekind枚举类型,代表的是当前callsite所属的类型,,而cache属性代表着服务实例对象的缓存配置

internal abstract class servicecallsite
{
     protected servicecallsite(resultcache cache)
     {
          cache = cache;
     }
     //      当前注册的服务类型
     public abstract type servicetype { get; }
     //        当前注册的实例化类型
     public abstract type implementationtype { get; }
     //      当前callsite所属的类型
     public abstract callsitekind kind { get; }
    //     服务实例对象的缓存配置
     public resultcache cache { get; }
}

resultcache和servicecachekey类型

internal struct resultcache
{
     //     默认resultcache  
     public static resultcache none { get; } = new resultcache(callsiteresultcachelocation.none, servicecachekey.empty);
     internal resultcache(callsiteresultcachelocation lifetime, servicecachekey cachekey)
     {
          location = lifetime;
          key = cachekey;
     }
    
     public resultcache(servicelifetime lifetime, type type, int slot)
     {
          switch (lifetime)
          {
               case servicelifetime.singleton:
                    location = callsiteresultcachelocation.root;
                    break;
               case servicelifetime.scoped:
                    location = callsiteresultcachelocation.scope;
                    break;
               case servicelifetime.transient:
                    location = callsiteresultcachelocation.dispose;
                    break;
               default:
                    location = callsiteresultcachelocation.none;
                    break;
          }
          key = new servicecachekey(type, slot);
     }
     //      当前服务实例缓存位置
     public callsiteresultcachelocation location { get; set; }
     ///     当前服务实例所缓存的使用key
     ///     servicecachekey使用基类类型和一个solt(一个数值,每实例化同一个基类类型时使用不同的solt)
     public servicecachekey key { get; set; }
}

//  缓存实例对象时使用key 
 internal struct servicecachekey: iequatable<servicecachekey>
    {
        public static servicecachekey empty { get; } = new servicecachekey(null, 0);
        //      注册服务类型
        public type type { get; }
        //      以ienumerable类型解析时服务的反向索引,默认实例0
        //      相同type时此值为++
        public int slot { get; }
        public servicecachekey(type type, int slot)
        {
            type = type;
            slot = slot;
        }
        public bool equals(servicecachekey other)
        {
            return type == other.type && slot == other.slot;
        }
        public override int gethashcode()
        {
            unchecked
            {
                return (type.gethashcode() * 397) ^ slot;
            }
        }
    }

servicecallsite

servicecallsite具有6个派生类型,分别是

• constantcallsite 服务注册是以单例模式以具体实例注册时使用
• constructorcallsite 服务注册是以类型注册,也就是实例化对象时以构造函数实例化
• factorycallsite 服务注册是以以工厂形式
• ienumerablecallsite 这个时调用获取当前注册类型的所有实例,也就是getservices()时
• serviceprovidercallsite 这个
• servicescopefactorycallsite 这个是获取子容器所使用,在engine类中会注册此类实例,然后获取子类容器使用

​

​ 这六个派生类中constantcallsite，ienumerablecallsite，serviceprovidercallsite和servicescopefactorycallsite这四个类的resultcache属性使用的是none，而constructorcallsite和factorycallsite的resultcache属性则由构造器传入，具体则有其服务注册的生命周期进行实例化resultcache

​

] 在这里看一下constantcallsite,constructorcallsite,ienumerablecallsite和servicescopefactorycallsite这四个类

constantcallsite

​ 既然constantcallsite是具体实例注册的,所以此类中具有一个实例对象属性,由下面代码可以看出在构造此类实例时传入实例值,然后赋值给defaultvalue属性,这个类型也是这些派生类中唯一一个拥有具体实例的,

​ 然后kind这个属性可以看到被赋值成了callsitekind.constant,前面说过这个属性相当于代表此类型的属性,其它派生类都具有相应的枚举值

internal class constantcallsite : servicecallsite
    {
        /// <summary>
        ///     注册时提供的具体实例对象值
        /// </summary>
       internal object defaultvalue { get; }

        public constantcallsite(type servicetype, object defaultvalue): base(resultcache.none)
        {
            defaultvalue = defaultvalue;
        }
        /// <summary>
        ///     注册的基类类型
        /// </summary>
        public override type servicetype => defaultvalue.gettype();
        /// <summary>
        ///     其实际对象所对应的类型
        /// </summary>
        public override type implementationtype => defaultvalue.gettype();
        /// <summary>
        ///     当前servicecallsite所对应的类型
        /// </summary>
        public override callsitekind kind { get; } = callsitekind.constant;
    }

constructorcallsite

​ 这个类中具有两个主要属性

constructorinfo：当前选中的最优构造器

parametercallsites：构造参数数组

internal class constructorcallsite : servicecallsite
{
     ///     实例化对象时所使用的构造器,当前构造器的最优构造器
     internal constructorinfo constructorinfo { get; }
     ///     当前构造器中所有参数的servicecallsite集合
     internal servicecallsite[] parametercallsites { get; }
     
     //     最优构造器为无参
     public constructorcallsite(resultcache cache, type servicetype, constructorinfo constructorinfo) : this(cache, servicetype, constructorinfo, array.empty<servicecallsite>())
     {}
     
     public constructorcallsite(resultcache cache, type servicetype, constructorinfo constructorinfo, servicecallsite[] parametercallsites) : base(cache)
     {
          servicetype = servicetype;
          constructorinfo = constructorinfo;
          parametercallsites = parametercallsites;
     }
     public override type servicetype { get; }
     //     使用构造器的declaringtype
     public override type implementationtype => constructorinfo.declaringtype;
     public override callsitekind kind { get; } = callsitekind.constructor;
}

ienumerablecallsite

​

​ ienumerablecallsite前面说过是对应的获取所有服务的访问设置类型,从下面代码可以看出其实这个类就是内部维护了一个servicecallsite数组和一个itemtype(这个代表真实的基类类型),并且要求实例对象时进行传入,然后最后实例化对象时遍历数组即可

internal class ienumerablecallsite : servicecallsite
    {
        /// <summary>
        ///     当前注册的类型  (基类类型)
        /// </summary>
        internal type itemtype { get; }
        /// <summary>
        ///     所有服务的servicecallsite数组
        /// </summary>
        internal servicecallsite[] servicecallsites { get; }

        public ienumerablecallsite(type itemtype, servicecallsite[] servicecallsites) : base(resultcache.none)
        {
            itemtype = itemtype;
            servicecallsites = servicecallsites;
        }

        public override type servicetype => typeof(ienumerable<>).makegenerictype(itemtype);
        public override type implementationtype  => itemtype.makearraytype();
        //      当前类型是ienumberable标志
        public override callsitekind kind { get; } = callsitekind.ienumerable;
    }

servicescopefactorycallsite

​

​ 这个类型是子容器的工厂类型,下面代码中看到implementationtype是一个serviceproviderengine类型,其实这个引擎类不止实现了iserviceproviderengine接口,还实现了iservicescopefactory

internal class servicescopefactorycallsite : servicecallsite
    {
        public servicescopefactorycallsite() : base(resultcache.none)
        {
        }

        public override type servicetype { get; } = typeof(iservicescopefactory);
        //      iserviceproviderengine派生类型,这个类型也实现了iservicescopefactory接口,所以是一个子容器工厂类型
        public override type implementationtype { get; } = typeof(serviceproviderengine);
        public override callsitekind kind { get; } = callsitekind.servicescopefactory;
    }

servicedescriptorcacheitem

​

​ 从下面代码可以看出这是一个结构,这个结构是具有相同注册服务的所有servicedescriptor封装,在callsitefactory类中进行使用

 private struct servicedescriptorcacheitem{}

​ 在此结构中,可以看到具有两个字段**_item属性和一个_items集合属性,_item属性代表相同注册服务的第一个servicedescriptor，而_items**则是除去第一个其它的servicedescriptor集合,我没看懂微软为什么要这么干

**_item**：代表此注册服务的第一个servicedescriptor

**_items**：此字段表示除去第一个的的所有servicedescriptor集合

​

​ 此结构中的last和count分别是获取缓存的最后一个元素和数量,因为第一个servicedescriptor是**_item属性,所以这两个属性都考虑了_item**,

/// <summary>
///     获取其注册的最后一个servicedescriptor
///     如果其_items集合为空,则获取其_item的值
/// </summary>
public servicedescriptor last
{
     get
     {
          if (_items != null && _items.count > 0)
            return _items[_items.count - 1];
          return _item;
     }
}
//     所有相同注册类型的数量,
//      因为第一个是_item,所以需要1+_items.count
public int count
{
     get
     {
        if (_item == null)
            return 0;
        return 1 + (_items?.count ?? 0);
     }
}
public servicedescriptor this[int index]
{
     get
     {
          if (index >= count)
               throw new argumentoutofrangeexception(nameof(index));
          if (index == 0)
               return _item;
          return _items[index - 1];
     }
}

​ 结构中只有一个and()方法,此方法是添加一个servicedescriptor,可以每次调用此方法时都会创建新的实例,

//     将指定固定servicedescriptor添加到集合中
//     首先实例化一个新的 servicedescriptorcacheitem对象
//     如果当前对象_item属性为空,则将当前参数作为新servicedescriptorcacheitem对象>item属性
//     如果当前对象_item不为空,则当前的对象_item作为新servicedescriptorcacheitem对象>item属性,并且将原对象集合赋值给新对象集合,并且将参数加入到新对象集合中,然后返回新对象,
//     也就是第一个加入的永远是_item值,其后加入的放入集合中
public servicedescriptorcacheitem add(servicedescriptor descriptor)
{
     var newcacheitem = new servicedescriptorcacheitem();
     if (_item == null)
          newcacheitem._item = descriptor;
     else
     {
          newcacheitem._item = _item;
          newcacheitem._items = _items ?? new list<servicedescriptor>();
          newcacheitem._items.add(descriptor);
     }
     return newcacheitem;
}

callsitefactory

​ 下面来看看callsitefactory这个类型,这是servicecallsite的工厂类型,内部根据servicedescriptor创建对应的servicecallsite,下面一点点来看看这个类型

下面代码中是callsitefactory类中的属性

defaultslot：此属性是默认的slot,默认为0

_descriptors：此属性是缓存所有的servicedescriptor

_callsitecache：servicecallsite的缓存集合

_descriptorlookup：servicedescriptorcacheitem缓存集合

internal class callsitefactory
{
     //      默认的slot为0,
     private const int defaultslot = 0;
     ///     存储所有注册服务类型
     private readonly list<servicedescriptor> _descriptors;
     ///     servicecallsite缓存集合
     private readonly concurrentdictionary<type, servicecallsite> _callsitecache = new concurrentdictionary<type, servicecallsite>();
     
     ///     所有注册的服务缓存类型
     ///     其中以所注册基类类型分组包装为一个servicedescriptorcacheitem类型,然后以注册的基类类型为key进行缓存
     private readonly dictionary<type, servicedescriptorcacheitem> _descriptorlookup = new dictionary<type, servicedescriptorcacheitem>();
}

​

​ 从下面代码可以看到callsitefactory类型构造函数需要一个ienumerable<servicedescriptor> descriptors,在构造函数中除了实例化_stackguard对象和缓存_descriptors之外,还调用了一个populate()方法,这个方法是初始化_descriptorlookup缓存

public callsitefactory(ienumerable<servicedescriptor> descriptors)
{
     _stackguard = new stackguard();
     _descriptors = descriptors.tolist();
     //      调用此方法缓存servicedescriptorcacheitem
     populate(descriptors);
}

​ 在populate方法中,首先经过了一系列的判断,最进行缓存

private void populate(ienumerable<servicedescriptor> descriptors)
{
     foreach (var descriptor in descriptors)
     {
          //      获取servicedescriptor对象中所注册的基类
          var servicetypeinfo = descriptor.servicetype.gettypeinfo();
          if (servicetypeinfo.isgenerictypedefinition)
          {
               // 如果当前基类是泛型类,
               //  那么如果其实际类型implementationtypeinfo类不是泛型类或者为抽象类,那么就抛出异常
               var implementationtypeinfo = descriptor.implementationtype?.gettypeinfo();
               if (implementationtypeinfo == null || !implementationtypeinfo.isgenerictypedefinition)
                    throw new argumentexception(
                    resources.formatopengenericservicerequiresopengenericimplementation(descriptor.servicetype),
                    nameof(descriptors));

               if (implementationtypeinfo.isabstract || implementationtypeinfo.isinterface)
                    throw new argumentexception(
                    resources.formattypecannotbeactivated(descriptor.implementationtype, descriptor.servicetype));
          }
          else if (descriptor.implementationinstance == null && descriptor.implementationfactory == null)
          {
               //      如果当前基类不为泛型类
               //      那么如果其实际类型为泛型类或者是抽象类型,那么就抛出异常
               var implementationtypeinfo = descriptor.implementationtype.gettypeinfo();

               if (implementationtypeinfo.isgenerictypedefinition ||
                   implementationtypeinfo.isabstract ||
                   implementationtypeinfo.isinterface)
                    throw new argumentexception(
                    resources.formattypecannotbeactivated(descriptor.implementationtype, descriptor.servicetype));
          }
          //      使用其注册的基类为key,将此servicedescriptor缓存到dictionary<type, servicedescriptorcacheitem>集合中
          //      servicedescriptorcacheitem是一个存放了所有相同注册基类的servicedescriptor
          //      servicedescriptorcacheitem中具有一个item属性和一个items集合
          //      item属性是注册的第一个此类型的servicedescriptor
          var cachekey = descriptor.servicetype;
          //        由于servicedescriptorcacheitem是一个结构,所以不会异常
          _descriptorlookup.trygetvalue(cachekey, out var cacheitem);
          _descriptorlookup[cachekey] = cacheitem.add(descriptor);
     }
}

​ 在此类中具有一个getcallsite()方法,外部也是调用此方法进行获取servicecallsite,如果当前servicecallsite已被缓存,则直接获取缓存中数据,如果未缓存,则创建并缓存,从下面代码可以看到,如果未被缓存就调用createcallsite()进行创建

​ 当前函数中有一个callsitechain类型,这个类型是一个限制,应该是为了防止多线程,在创建之前进行了判断,如果已创建,则抛出异常,callsitechain这个类在此就不做介绍

internal servicecallsite getcallsite(type servicetype, callsitechain callsitechain)
     => _callsitecache.getoradd(servicetype, (type, chain) => createcallsite(type, chain), callsitechain);

​ 在createcallsite()首先调用了callsitechain实例的checkcirculardependency()方法,这个方法就是如果已被创建,则抛出异常.然后分别调用trycreateexact(),trycreateopengeneric(),trycreateenumerable()这三个方法进行尝试实例化servicecallsite,下面我们来看看这三个方法和它们依赖的方法

private servicecallsite createcallsite(type servicetype, callsitechain callsitechain)
{
     servicecallsite callsite;
     try
     {
          //      检查是否已被创建,如果已创建,则抛出异常
          callsitechain.checkcirculardependency(servicetype);
          //      获取指定服务的实例对象方式
          //          1.首先创建普通类型的servicecallsite,
          //          2.创建泛型类型的servicecallsite
          //          3.如果服务类型是集合.那么将获取当前类型所有实现对象
          callsite = trycreateexact(servicetype, callsitechain) ??
               trycreateopengeneric(servicetype, callsitechain) ??
               trycreateenumerable(servicetype, callsitechain);
     }
     finally
     {
          callsitechain.remove(servicetype);
     }
     _callsitecache[servicetype] = callsite;

     return callsite;
}

1.trycreateexact()

​ trycreateexact()方法是如果servicetype只是一个普通类型时才使用的方法,如下代码,首先判断了此类型是否存在于**_descriptorlookup缓存中,如果不存在直接返回null,如果存在的话直接使用最后一个servicedescriptor和defaultslot**进行,这也就是为什么总是会获取最后一个服务实例的原因

private servicecallsite trycreateexact(type servicetype, callsitechain callsitechain)
{
     //      在_descriptorlookup缓存中获取指定基类的所有servicedescriptor实例,
     //      然后利用最后一个servicedescriptor进行实例化servicecallsite
     if (_descriptorlookup.trygetvalue(servicetype, out var descriptor))
        return trycreateexact(descriptor.last, servicetype, callsitechain, defaultslot);
     return null;
}

​ trycreateexact()中则根据注册服务的方式进行实例化servicecallsite可以看到使用具体实例对象和工厂时直接实例化servicecallsite,而使用类型注册时则又调用createconstructorcallsite()进行实例化一个constructorcallsite对象

private servicecallsite trycreateexact(servicedescriptor descriptor, type servicetype, callsitechain callsitechain, int slot)
{
     //      判断基类类型是否与servicedescriptor所持有的基类类型是否一致,如果不一致直接返回false
     if (servicetype == descriptor.servicetype)
     {
          servicecallsite callsite;
          //      根据当前注册的生命周期,基类类型和slot实例化一个resultcache,
          //      resultcache类型具有一个最后结果缓存的位置(相当于跟生命周期一致)和一个缓存key
          var lifetime = new resultcache(descriptor.lifetime, servicetype, slot);
          //      根据注册时所使用的方式来创建不同的servicecallsite,共具有三种servicecallsite子类
          //      constantcallsite    注册时直接根据对象进行实例化具体对象(singleton生命周期独有)
          //      factorycallsite     注册时根据一个工厂实例化对象
          //      constructorcallsite 注册时根据具体实例类型进行实例化对象
          if (descriptor.implementationinstance != null)
               callsite = new constantcallsite(descriptor.servicetype, descriptor.implementationinstance);
          else if (descriptor.implementationfactory != null)
               callsite = new factorycallsite(lifetime, descriptor.servicetype, descriptor.implementationfactory);
          else if (descriptor.implementationtype != null)
               //      如果注册类型是使用的派生类类型方式,则调用createconstructorcallsite来实例化一个constructorcallsite
               callsite = createconstructorcallsite(lifetime, descriptor.servicetype, descriptor.implementationtype, callsitechain);
          else
               throw new invalidoperationexception("invalid service descriptor");
          return callsite;
     }
     return null;
}

​ 下面看一下createconstructorcallsite()这个方法,在这个方法中选择最优构造器并实例化constructorcallsite对象,

首先获取实例类型的所有公共构造器,如果不存在就抛出异常

如果此类型只有一个构造器,那么就使用此构造器当做最优构造器进行实例化,

如果此类型具有多个构造器,那么就选出最优构造器

如果没有找到最优构造器,就抛出异常,存在最优构造器就以此构造器实例化constructorcallsite

注：最优构造器是参数最多的构造器,但是如果其它构造器参数中具有最优构造器没有的参数,就抛出异常

​ 在此方法中如果最优构造器拥有参数,还会调用一个createargumentcallsites(),这个方法会依次实例化参数的servicecallsite

private servicecallsite createconstructorcallsite(resultcache lifetime, type servicetype, type implementationtype,callsitechain callsitechain)
{
     //      将此服务类型和实例类型存入callsitechain
     callsitechain.add(servicetype, implementationtype);
     //      获取实例类型的所有公共构造器,
     //      然后选择其最优的构造器并创建constructorcallsite  
     var constructors = implementationtype.gettypeinfo()
          .declaredconstructors
          .where(constructor => constructor.ispublic)
          .toarray();
     servicecallsite[] parametercallsites = null;
     if (constructors.length == 0)
          //     没有公共构造器,直接抛出异常
          throw new invalidoperationexception(resources.formatnoconstructormatch(implementationtype));
     else if (constructors.length == 1)
     {
          //     如果当前构造器为1个,则判断构造器是否存在参数并将所有参数进行实例化(创建指定的servicecallsite),
          var constructor = constructors[0];
          //      获取当前构造器的所有参数,并对参数一一进行创建servicecallsite  递归调用
          var parameters = constructor.getparameters();
          if (parameters.length == 0)
          {
               return new constructorcallsite(lifetime, servicetype, constructor);
          }
          //      创建当前构造器所有参数的servicecallsite
          //      如果具有未知的参数,则直接抛出异常
          parametercallsites = createargumentcallsites(
               servicetype,
               implementationtype,
               callsitechain,
               parameters,
               throwifcallsitenotfound: true);

          return new constructorcallsite(lifetime, servicetype, constructor, parametercallsites);
     }
     //      根据构造器参数长度进行排序,判断所有构造器中是否具有未知参数
     array.sort(constructors,
                (a, b) => b.getparameters().length.compareto(a.getparameters().length));

     //      最优构造器
     constructorinfo bestconstructor = null;
     hashset<type> bestconstructorparametertypes = null;
     for (var i = 0; i < constructors.length; i++)
     {
          var parameters = constructors[i].getparameters();
          //      创建当前构造器所有参数的servicecallsite
          //      如果具有未知的参数,则不抛出异常
          var currentparametercallsites = createargumentcallsites(
               servicetype,
               implementationtype,
               callsitechain,
               parameters,
               throwifcallsitenotfound: false);

          if (currentparametercallsites != null)
          {
               //  如果所有参数的servicecallsite构造成功,并且当前最优构造器对象为空,则将当前构造器设置为最优构造器
               if (bestconstructor == null)
               {
                    bestconstructor = constructors[i];
                    parametercallsites = currentparametercallsites;
               }
               else
               {
                    if (bestconstructorparametertypes == null)
                         //      如果最优参数类型集合为空,则将当前构造器的参数赋给集合
                         bestconstructorparametertypes = new hashset<type>(
                         bestconstructor.getparameters().select(p => p.parametertype));
                    //      如果bestconstructorparametertypes为不为当前构造参数集合的子集,则抛出异常
                    //      子集指当前bestconstructorparametertypes集合中所有数据是否在当前构造参数集合之中
                    if (!bestconstructorparametertypes.issupersetof(parameters.select(p => p.parametertype)))
                    {
                         // ambiguous match exception
                         var message = string.join(
                              environment.newline,
                              resources.formatambiguousconstructorexception(implementationtype),
                              bestconstructor,
                              constructors[i]);
                         throw new invalidoperationexception(message);
                    }
               }
          }
     }
     //      如果未找到最优构造函数,则抛出异常
     if (bestconstructor == null)
          throw new invalidoperationexception(
          resources.formatunabletoactivatetypeexception(implementationtype));
     else
          //      实例化一个constructorcallsite对象并返回
          return new constructorcallsite(lifetime, servicetype, bestconstructor, parametercallsites);
}

​ 在createargumentcallsites()中递归调用getcallsite()获取每一个参数对应的servicecallsite,在方法中可以看到如果从getcallsite()中未获取到对应的实例对象但是该参数具有默认参数,那么就使用默认参数.

​ 在这个方法有意思的是最后一个参数,最后一个参数如果为true，那么如果最终未获取到参数的servicecallsite就抛出一场，如果为false，就返回null

private servicecallsite[] createargumentcallsites(
     type servicetype,
     type implementationtype,
     callsitechain callsitechain,
     parameterinfo[] parameters,
     bool throwifcallsitenotfound)
{
     var parametercallsites = new servicecallsite[parameters.length];
     for (var index = 0; index < parameters.length; index++)
     {
          //      依次递归调用获取指定参数的servicecallsite
          var callsite = getcallsite(parameters[index].parametertype, callsitechain);
          if (callsite == null && parameterdefaultvalue.trygetdefaultvalue(parameters[index], out var defaultvalue))
               //          如果获取参数的servicecallsite失败但是该参数具有默认值
               //          则直接以默认值来创建constantcallsite对象
               callsite = new constantcallsite(servicetype, defaultvalue);
          //      如果当前callsite还为空,则代表出现无法实例化的参数类型
          //      如果允许抛出异常则抛出异常,如果不允许抛出异常则返回null
          if (callsite == null)
          {
               if (throwifcallsitenotfound)
                    throw new invalidoperationexception(resources.formatcannotresolveservice(
                         parameters[index].parametertype,
                         implementationtype));
               return null;
          }

          parametercallsites[index] = callsite;
     }
     return parametercallsites;
}

2.trycreateopengeneric()

​ 从下面代码可以看出trycreateopengeneric()首先会判断此泛型是否是封闭类型并且此类型是否存在于**_descriptorlookup,然后调用trycreateopengeneric()**进行获取servicecallsite

​ 在trycreateopengeneric()中则根据注册服务类型的泛型参数制造一个实现类型参数,然后调用createconstructorcallsite()进行实例化servicecallsite,所以泛型只能以构造器实例方式

private servicecallsite trycreateopengeneric(type servicetype, callsitechain callsitechain)
{
     //      如果是泛型是封闭并且在_descriptorlookup缓存集合中具有此类型的缓存
     if (servicetype.isconstructedgenerictype
         && _descriptorlookup.trygetvalue(servicetype.getgenerictypedefinition(), out var descriptor))
            return trycreateopengeneric(descriptor.last, servicetype, callsitechain, defaultslot);
     return null;
}

private servicecallsite trycreateopengeneric(servicedescriptor descriptor, type servicetype, callsitechain callsitechain, int slot)
{
     //   如果当前泛型类型为封闭并且当前注册的基类类型为当前泛型的开放类型,则实例化,否则返回null
     if (servicetype.isconstructedgenerictype &&
         servicetype.getgenerictypedefinition() == descriptor.servicetype)
     {
          //  利用当前注册服务的声明和生命周期类型实例化一个结果缓存配置
          var lifetime = new resultcache(descriptor.lifetime, servicetype, slot);
          //     利用注册类型泛型参数创造派生类封闭泛型类型
          var closedtype = descriptor.implementationtype.makegenerictype(servicetype.generictypearguments);
          //      创建一个constructorcallsite并返回
          return createconstructorcallsite(lifetime, servicetype, closedtype, callsitechain);
     }
     return null;
}

3.trycreateenumerable()

​ 最后我们来看看trycreateenumerable()这个方法,这个方法就是获取ienumerablecallsite类型的,也就是获取当前注册类型所有实例时使用的,从下面代码可以看到如果ienumerable的泛型参数不是泛型并且缓存于**_descriptorlookup集合中,就使用对应的所有的serviceprovider进行实例化，如果二者有一不可就遍历_descriptors**实例servicecallsite

private servicecallsite trycreateenumerable(type servicetype, callsitechain callsitechain)
{
     //      类型是封闭泛型类型并且泛型集合为ienumerable
     if (servicetype.isconstructedgenerictype &&
         servicetype.getgenerictypedefinition() == typeof(ienumerable<>))
     {
          //      获取当前注册类型集合的泛型参数,由此类型来当基类类型进行获取注册当前类型的所有服务servicecallsite
          var itemtype = servicetype.generictypearguments.single();

          callsitechain.add(servicetype);

          var callsites = new list<servicecallsite>();

          if (!itemtype.isconstructedgenerictype &&
              _descriptorlookup.trygetvalue(itemtype, out var descriptors))
          {
               //  如果泛型类型不是泛型并存在于缓存中
               for (int i = 0; i < descriptors.count; i++)
               {
                    //      一次获取其中每一个servicedecriptor然后创建对应的servicecallsite
                    var descriptor = descriptors[i];
                    //  设置当前slot
                    //   slot为倒序设置
                    var slot = descriptors.count - i - 1;
                    // there may not be any open generics here
                    //      获取当前servicedecriptor的servicecallsite并添加数组中
                    var callsite = trycreateexact(descriptor, itemtype, callsitechain, slot);
                    callsites.add(callsite);
               }
          }
          else
          {
               var slot = 0;
               for (var i = _descriptors.count - 1; i >= 0; i--)
               {
                    //遍历所有注册的servicedescriptor并获取对应的servicecallsite,然后如果不为空则添加至数组中
                    var descriptor = _descriptors[i];
                    var callsite = trycreateexact(descriptor, itemtype, callsitechain, slot) ??
                         trycreateopengeneric(descriptor, itemtype, callsitechain, slot);
                    slot++;
                    if (callsite != null)
                         callsites.add(callsite);
               }
               //      反转集合元素
               callsites.reverse();
          }
          //  实例化ienumerablecallsite并返回
          return new ienumerablecallsite(itemtype, callsites.toarray());
     }
     return null;
}

​ 在callsitefactory类中还具有一个add(),这个方法是往**_callsitecache**字段添加缓存servicecallsite

 public void add(type type, servicecallsite servicecallsite)
      => _callsitecache[type] = servicecallsite;