06-006 DependencyInjection 之 IService

IService 代码：

   internal interface IService
    {
        IService Next { get; set; }

        LifecycleKind Lifecycle { get; }

        IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain);
    }

实现IService接口的类有如下几个：

 internal class ClosedIEnumerableService : IService
 internal class FactoryService : IService, IServiceCallSite
 internal class InstanceService : IService, IServiceCallSite
 internal class Service : IService
 internal class ServiceProviderService : IService, IServiceCallSite
 internal class ServiceScopeService : IService, IServiceCallSite

 先说一下：ClosedIEnumerableService 和 OpenIEnumerableService 的区别：Open 无指定泛型的类型 Close 已经指定的类型：

 _table.Add(typeof(IEnumerable<>), new OpenIEnumerableService(_table));

 先看一下 1 FactoryService:

        private readonly IServiceDescriptor _descriptor;

        public FactoryService(IServiceDescriptor descriptor)
        {
            _descriptor = descriptor;
        }

        public IService Next { get; set; }

        public LifecycleKind Lifecycle
        {
            get { return _descriptor.Lifecycle; }
        }

        public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
        {
            return this;
        }

        public object Invoke(ServiceProvider provider)
        {
            return _descriptor.ImplementationFactory(provider);
        }

 CreateCallSite 返回自己，Invoke 则调用传递过来的方法；

2.InstanceService 代码：

        private readonly IServiceDescriptor _descriptor;

        public InstanceService(IServiceDescriptor descriptor)
        {
            _descriptor = descriptor;
        }

        public IService Next { get; set; }

        public LifecycleKind Lifecycle
        {
            get { return _descriptor.Lifecycle; }
        }

        public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
        {
            return this;
        }

        public object Invoke(ServiceProvider provider)
        {
            return _descriptor.ImplementationInstance;
        }

 与 FactoryService 类似，descriptor 传递过来的 直接返回。

3.Service 部分代码  生命周期Lifecycle同传递过来的 ：

        public Service(IServiceDescriptor descriptor)
        {
            _descriptor = descriptor;
        }

        public IService Next { get; set; }

        public LifecycleKind Lifecycle
        {
            get { return _descriptor.Lifecycle; }
        }

 这里看一下：CreateCallSite 的代码：目的是用来包含创建对象的CallSite

  public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
        {
            ConstructorInfo[] constructors = _descriptor.ImplementationType.GetTypeInfo()
                .DeclaredConstructors
                .Where(IsInjectable)
                .ToArray();

			// TODO: actual service-fulfillment constructor selection
			//可注入有参数构造函数只能有一个  return constructor.IsPublic && constructor.GetParameters().Length != 0;
			if (constructors.Length == 1)
            {
                ParameterInfo[] parameters = constructors[0].GetParameters();
                IServiceCallSite[] parameterCallSites = new IServiceCallSite[parameters.Length];
                for (var index = 0; index != parameters.Length; ++index)
                {
					//先从 ServiceCollection 里找
                    parameterCallSites[index] = provider.GetServiceCallSite(parameters[index].ParameterType, callSiteChain);
                
                    if (parameterCallSites[index] == null && parameters[index].HasDefaultValue)
                    {  
						// 找不到 有默认值的 赋值
                        parameterCallSites[index] = new ConstantCallSite(parameters[index].DefaultValue);
                    }
                    if (parameterCallSites[index] == null)
                    {
						// 无默认值的 抛异常 无法解析服务
                        throw new InvalidOperationException(Resources.FormatCannotResolveService(
                                parameters[index].ParameterType, 
                                _descriptor.ImplementationType));
                    }
                }
				//有参数构造函数对象创建
                return new ConstructorCallSite(constructors[0], parameterCallSites);
            }
			//无参数构造函数对象创建
            return new CreateInstanceCallSite(_descriptor);
        }

 4.ServiceProviderService：

 internal class ServiceProviderService : IService, IServiceCallSite
    {
        public IService Next { get; set; }

        public LifecycleKind Lifecycle
        {
            get { return LifecycleKind.Scoped; }
        }

        public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
        {
            return this;
        }

        public object Invoke(ServiceProvider provider)
        {
            return provider;
        }

        public Expression Build(Expression provider)
        {
            return provider;
        }
    }

 这是系统默认添加的一个接口的实现：

  _table.Add(typeof(IServiceProvider), new ServiceProviderService());  

 调用的时候；用的是 new ServiceProviderService().CreateCallSite(--).Invoke( provider);

即：Invoke 什么 就返回什么；

5.再看一下 ServiceScopeService 的代码：

internal class ServiceScopeService : IService, IServiceCallSite
    {
        public IService Next { get; set; }

        public LifecycleKind Lifecycle
        {
            get { return LifecycleKind.Scoped; }
        }

        public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
        {
            return this;
        }

        public object Invoke(ServiceProvider provider)
        {
            return new ServiceScopeFactory(provider);
        }

        public Expression Build(Expression provider)
        {
            return Expression.New(
                typeof(ServiceScopeFactory).GetTypeInfo()
                    .DeclaredConstructors
                    .Single(),
                provider);
        }
    }

 return this；的核心代码在于 Invoke 方法： 这里新创建一个 ServiceScopeFactory：

  internal class ServiceScopeFactory : IServiceScopeFactory
    {
        private readonly ServiceProvider _provider;

        public ServiceScopeFactory(ServiceProvider provider)
        {
            _provider = provider;
        }

        public IServiceScope CreateScope()
        {
			//如何实现同一个Scope 对象只创建一次
			// 原因是在Scope里面 New 了一个  ServiceProvider
			// New 的对象存储在  ServiceProvider 里的：
			//  private readonly Dictionary<IService, object> _resolvedServices = new Dictionary<IService, object>();
			return new ServiceScope(new ServiceProvider(_provider));
        }
    }

 6. 最后看一下 ClosedIEnumerableService ：

   public LifecycleKind Lifecycle
        {
            get { return LifecycleKind.Transient; }
        }

        public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
        {
            var list = new List<IServiceCallSite>();
            for (var service = _serviceEntry.First; service != null; service = service.Next)
            {
				// 还记得前文中的 A1，A2，A3 吗？
				// 这里依次 增加
                list.Add(provider.GetResolveCallSite(service, callSiteChain));
            }

			//如果Collection 里 添加了 IA-A1 IA-A2 IA-A3
			//当需要用到 INumberable<IA> 的时候 就会创建 一个包含 A1 A2 A3 的数组

            return new CallSite(_itemType, list.ToArray()); //对数组的包装
        }