//定义 public class ServiceCollection : IServiceCollection { private readonly List<ServiceDescriptor> _descriptors = new List<ServiceDescriptor>(); ...... } //接口定义 public interface IServiceCollection : IList<ServiceDescriptor> { }
由此可见，ServiceCollection 本身是一个 List<ServiceDescriptor> 的集合，下面我们来看一下 ServiceDescriptor 的定义
public class ServiceDescriptor { //重要的构造函数 public ServiceDescriptor(Type serviceType, Type implementationType, ServiceLifetime lifetime) { } //重要的属性 /// <summary> /// Service 的生命周期 /// </summary> /// <value></value> public ServiceLifetime Lifetime { get; } /// <summary> /// Service 的类型 /// </summary> /// <value></value> public Type ServiceType { get; } /// <summary> /// Service 的实现类型 /// </summary> /// <value></value> public Type ImplementationType { get; } /// <summary> /// Service 对象 /// </summary> /// <value></value> public object ImplementationInstance { get; } /// <summary> /// 创建 Service 对象的工厂 /// </summary> /// <value></value> public Func<IServiceProvider, object> ImplementationFactory { get; } ...... }
ServiceDescriptor 保存了 Service 类型和 Service 对象之间的关系以及 Service 的生命周期，下面来看一下 Service 的生命周期
public enum ServiceLifetime { /// <summary> /// 单例 /// </summary> Singleton, /// <summary> /// 范围内 /// </summary> /// <remarks> /// 在 ASP.NET Core 应用中，每一个请求会创建一个范围 /// </remarks> Scoped, /// <summary> /// 瞬时 /// </summary> Transient }
再来看一下 IServiceCollection 提供的一些拓展方法
public static class ServiceCollectionServiceExtensions { //基本是3中形式，都是简单的封装 public static IServiceCollection AddSingleton(this IServiceCollection services, ...) public static IServiceCollection AddScoped(this IServiceCollection services, ...) public static IServiceCollection AddTransient(this IServiceCollection services, ...) ...... //最终都会调用同一个方法 private static IServiceCollection Add( IServiceCollection collection, Type serviceType, Type implementationType, ServiceLifetime lifetime) { var descriptor = new ServiceDescriptor(serviceType, implementationType, lifetime); collection.Add(descriptor); return collection; } }
这些方法的作用都是为了填充 ServiceCollection 中的 _descriptors 字段，IServiceCollection 有一个特别重要的方法，BuildServiceProvider，创建 ServiceProvider
public static class ServiceCollectionContainerBuilderExtensions { public static ServiceProvider BuildServiceProvider(this IServiceCollection services, ServiceProviderOptions options) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } return new ServiceProvider(services, options); } }
public sealed class ServiceProvider : IServiceProvider, IDisposable{
//ServiceProvider 引擎 private readonly IServiceProviderEngine _engine; //构造函数 internal ServiceProvider(IEnumerable<ServiceDescriptor> serviceDescriptors, ServiceProviderOptions options) { ...... switch (options.Mode) { case ServiceProviderMode.Default:
//.net core 默认是 true if (RuntimeFeature.IsSupported("IsDynamicCodeCompiled")) { _engine = new DynamicServiceProviderEngine(serviceDescriptors, callback); }
else { // Don‘t try to compile Expressions/IL if they are going to get interpreted _engine = new RuntimeServiceProviderEngine(serviceDescriptors, callback); } break; case ServiceProviderMode.Dynamic: _engine = new DynamicServiceProviderEngine(serviceDescriptors, callback); break; case ServiceProviderMode.Runtime: _engine = new RuntimeServiceProviderEngine(serviceDescriptors, callback); break; case ServiceProviderMode.ILEmit: _engine = new ILEmitServiceProviderEngine(serviceDescriptors, callback); break; case ServiceProviderMode.Expressions: _engine = new ExpressionsServiceProviderEngine(serviceDescriptors, callback); break; default: throw new NotSupportedException(nameof(options.Mode)); } ...... } //从容器中获取对象 public object GetService(Type serviceType) => _engine.GetService(serviceType); ...... }
由此可见，ServiceProvider 创建对象的过程由 ServiceProviderEngine 接管，而 Engine 有4种，分别是 DynamicServiceProviderEngine，RuntimeServiceProviderEngine，ILEmitServiceProviderEngine，ExpressionsServiceProviderEngine，下面是他们之间的关系，
internal abstract class ServiceProviderEngine : IServiceProviderEngine, IServiceScopeFactory { private readonly Func<Type, Func<ServiceProviderEngineScope, object>> _createServiceAccessor; protected ServiceProviderEngine(IEnumerable<ServiceDescriptor> serviceDescriptors, IServiceProviderEngineCallback callback) { _createServiceAccessor = CreateServiceAccessor; Root = new ServiceProviderEngineScope(this); RuntimeResolver = new CallSiteRuntimeResolver(); CallSiteFactory = new CallSiteFactory(serviceDescriptors); CallSiteFactory.Add(typeof(IServiceProvider), new ServiceProviderCallSite()); CallSiteFactory.Add(typeof(IServiceScopeFactory), new ServiceScopeFactoryCallSite()); RealizedServices = new ConcurrentDictionary<Type, Func<ServiceProviderEngineScope, object>>(); }
//创建 Service 访问者 private Func<ServiceProviderEngineScope, object> CreateServiceAccessor(Type serviceType) { var callSite = CallSiteFactory.GetCallSite(serviceType, new CallSiteChain()); if (callSite != null) { //调用子类实现的 获得 Service 对象的委托来创建对象 return RealizeService(callSite); } return _ => null; }
//调用目标工厂 internal CallSiteFactory CallSiteFactory { get; } //默认运行时解析器 protected CallSiteRuntimeResolver RuntimeResolver { get; } //根容器 public ServiceProviderEngineScope Root { get; } //获得 Service 对象的委托，由子类实现 protected abstract Func<ServiceProviderEngineScope, object> RealizeService(ServiceCallSite callSite); //获取 Service 对象 internal object GetService(Type serviceType, ServiceProviderEngineScope serviceProviderEngineScope) { var realizedService = RealizedServices.GetOrAdd(serviceType, _createServiceAccessor); return realizedService.Invoke(serviceProviderEngineScope); } //创建一个范围 public IServiceScope CreateScope() { return new ServiceProviderEngineScope(this); } }
这个类中有几个特别重要的对象，
internal class DynamicServiceProviderEngine : CompiledServiceProviderEngine { //该类本身并没有定义 RutimeResolver 而是通过父类 CompiledServiceProviderEngine 的 ResolverBuilder 实现的 } internal abstract class CompiledServiceProviderEngine : ServiceProviderEngine { //通过编译条件变量来确定是使用 ILEmit 还是使用 Expression #if IL_EMIT public ILEmitResolverBuilder ResolverBuilder { get; } #else public ExpressionResolverBuilder ResolverBuilder { get; } #endif public CompiledServiceProviderEngine(IEnumerable<ServiceDescriptor> serviceDescriptors, IServiceProviderEngineCallback callback) : base(serviceDescriptors, callback) { #if IL_EMIT ResolverBuilder = new ILEmitResolverBuilder(RuntimeResolver, this, Root); #else ResolverBuilder = new ExpressionResolverBuilder(RuntimeResolver, this, Root); #endif } ...... } internal class RuntimeServiceProviderEngine : ServiceProviderEngine { //该类本身没有对应的 RuntimeResolver，直接使用父类默认的 CallSiteRuntimeResolver } internal class ILEmitServiceProviderEngine : ServiceProviderEngine { private readonly ILEmitResolverBuilder _expressionResolverBuilder; public ILEmitServiceProviderEngine(IEnumerable<ServiceDescriptor> serviceDescriptors, IServiceProviderEngineCallback callback) : base(serviceDescriptors, callback) { _expressionResolverBuilder = new ILEmitResolverBuilder(RuntimeResolver, this, Root); } ...... } internal class ExpressionsServiceProviderEngine : ServiceProviderEngine { private readonly ExpressionResolverBuilder _expressionResolverBuilder; public ExpressionsServiceProviderEngine(IEnumerable<ServiceDescriptor> serviceDescriptors, IServiceProviderEngineCallback callback) : base(serviceDescriptors, callback) { _expressionResolverBuilder = new ExpressionResolverBuilder(RuntimeResolver, this, Root); } ...... }
所以总结来看，有3个对应的 Resolver 分别是：CallSiteRuntimeResolver，ILEmitResolverBuilder，ExpressionResolverBuilder 这3个类都继承于 CallSiteVisitor<TArgument, TResult> 的泛型类，只是对应的泛型参数不太一样
internal class CallSiteFactory { private const int DefaultSlot = 0; private readonly List<ServiceDescriptor> _descriptors; private readonly Dictionary<Type, ServiceDescriptorCacheItem> _descriptorLookup = new Dictionary<Type, ServiceDescriptorCacheItem>(); public CallSiteFactory(IEnumerable<ServiceDescriptor> descriptors) { _descriptors = descriptors.ToList(); Populate(); } private void Populate() { /* 在实例化 CallSiteFactory 对象时，会将 ServiceDescriptor 对象转换成字典 Dictionary<Type, ServiceDescriptorCacheItem>， ServiceDescriptorCacheItem 用来将同一个 ServiceType 的 ServiceDescriptor 聚合在一起，其中 ServiceDescriptorCacheItem 的 Last 属性，是取最后一个 ServiceDescriptor，这也就是为什么，我们 Add 同一个类型的多个实例时，获取当前类型的实例时，返回的是最后一个实例的原因 */ foreach (var descriptor in _descriptors) { var cacheKey = descriptor.ServiceType; _descriptorLookup.TryGetValue(cacheKey, out var cacheItem); _descriptorLookup[cacheKey] = cacheItem.Add(descriptor); } } } private struct ServiceDescriptorCacheItem { private List<ServiceDescriptor> _items; public ServiceDescriptor Last { get { return _items[_items.Count - 1]; } } public ServiceDescriptorCacheItem Add(ServiceDescriptor descriptor) { var newCacheItem = new ServiceDescriptorCacheItem(); newCacheItem._item = _item; newCacheItem._items = _items ?? new List<ServiceDescriptor>(); newCacheItem._items.Add(descriptor); return newCacheItem; } }
还有几个比较关键的方法，下面来看一下代码
/* 根据 ServiceType 创建 ServiceCallSite, 这个方法类似于一个职责链模式， 先尝试根据普通类型来创建，然后尝试创建泛型类型，最后尝试创建可枚举类型 */ private ServiceCallSite CreateCallSite(Type serviceType, CallSiteChain callSiteChain) { var callSite = TryCreateExact(serviceType, callSiteChain) ?? TryCreateOpenGeneric(serviceType, callSiteChain) ?? TryCreateEnumerable(serviceType, callSiteChain); return callSite; } //尝试获取简单类型对象 private ServiceCallSite TryCreateExact(Type serviceType, CallSiteChain callSiteChain) { if (_descriptorLookup.TryGetValue(serviceType, out var descriptor)) { /* descriptor.Last 这就是为什么在容器中添加同一个类型的实例多次后，返回的总是最后一个实例 */ return TryCreateExact(descriptor.Last, serviceType, callSiteChain, DefaultSlot); } return null; }
private ServiceCallSite TryCreateExact(ServiceDescriptor descriptor, Type serviceType, CallSiteChain callSiteChain, int slot) { if (serviceType == descriptor.ServiceType) { if (descriptor.ImplementationInstance != null) { //Add 时，直接指定实例对象时 callSite = new ConstantCallSite(descriptor.ServiceType, descriptor.ImplementationInstance); } else if (descriptor.ImplementationFactory != null) { //Add 时，指定实例工厂时 callSite = new FactoryCallSite(lifetime, descriptor.ServiceType, descriptor.ImplementationFactory); } else if (descriptor.ImplementationType != null) { //Add 时，指定类型时 callSite = CreateConstructorCallSite(lifetime, descriptor.ServiceType, descriptor.ImplementationType, callSiteChain); } return callSite; } return null; } //尝试获取泛型对象 private ServiceCallSite TryCreateOpenGeneric(ServiceDescriptor descriptor, Type serviceType, CallSiteChain callSiteChain, int slot) { if (serviceType.IsConstructedGenericType && serviceType.GetGenericTypeDefinition() == descriptor.ServiceType) { var closedType = descriptor.ImplementationType.MakeGenericType(serviceType.GenericTypeArguments); return CreateConstructorCallSite(lifetime, serviceType, closedType, callSiteChain); } return null; } //尝试获取枚举类型对象 private ServiceCallSite TryCreateEnumerable(Type serviceType, CallSiteChain callSiteChain) { if (serviceType.IsConstructedGenericType && serviceType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) { //获取泛型的第一个参数 var itemType = serviceType.GenericTypeArguments.Single(); var callSites = new List<ServiceCallSite>(); if (!itemType.IsConstructedGenericType && _descriptorLookup.TryGetValue(itemType, out var descriptors)) { /* 循环该 ServiceType 所有的 ServiceDescriptor 这就是为什么在容器中添加同一个类型的实例多次后，通过 IEnumerable<T> 去获取时，返回的是多个实例 */ for (int i = 0; i < descriptors.Count; i++) { var descriptor = descriptors[i]; var callSite = TryCreateExact(descriptor, itemType, callSiteChain, slot); callSites.Add(callSite); } } else { //这里的逻辑代表的是泛型中嵌套泛型的情况，是一个递归调用 } return new IEnumerableCallSite(resultCache, itemType, callSites.ToArray()); } return null; } private ServiceCallSite CreateConstructorCallSite(ResultCache lifetime, Type serviceType, Type implementationType, CallSiteChain callSiteChain) { //获取公共的构造函数 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) { //当只有一个构造函数时，优化处理逻辑 return new ConstructorCallSite(...); } //存在多个构造函数时，按照构造函数参数的个数倒序排列 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(); var currentParameterCallSites = CreateArgumentCallSites(...); /* 默认参数最多的构造函数为最优的构造函数，但是要根据参数类型在容器中是否存在来判断， 如果参数多的构造函数，有个别参数在容器中不存在，那么该构造函数不是最优的 */ if (currentParameterCallSites != null) { if (bestConstructor == null) { bestConstructor = constructors[i]; parameterCallSites = currentParameterCallSites; } else { if (bestConstructorParameterTypes == null) { bestConstructorParameterTypes = new HashSet<Type>(bestConstructor.GetParameters().Select(p => p.ParameterType)); } //如果最优构造函数的参数类型，不是其他构造函数的参数类型的超级，抛出【有歧义】的异常 if (!bestConstructorParameterTypes.IsSupersetOf(parameters.Select(p => p.ParameterType))) { throw new InvalidOperationException(message); } } } } return new ConstructorCallSite(lifetime, serviceType, bestConstructor, parameterCallSites); }
由于 ServiceProvider 容器本身只支持构造函数注入，所以我们主要关注每个 Resolver 的 VisitConstructor 方法，
CallSiteRuntimeResolver (.net framework 4.6.2 + 默认使用的方式)
internal sealed class CallSiteRuntimeResolver : CallSiteVisitor<RuntimeResolverContext, object> { protected override object VisitConstructor(ConstructorCallSite constructorCallSite, RuntimeResolverContext context) { object[] parameterValues; if (constructorCallSite.ParameterCallSites.Length == 0) { parameterValues = Array.Empty<object>(); } else { //循环获取每个参数类型的实例，如果参数类型还依赖于其它的类型，则会递归获取 parameterValues = new object[constructorCallSite.ParameterCallSites.Length]; for (var index = 0; index < parameterValues.Length; index++) { parameterValues[index] = VisitCallSite(constructorCallSite.ParameterCallSites[index], context); } } return constructorCallSite.ConstructorInfo.Invoke(parameterValues); } }
/* 由于 IL 我懂的也不是很多，只是大概知道，需要把参数提前准备好放在堆栈上，然后调用 Newobj 就可以实例化对象， 源码很长，有兴趣想要研究的小伙伴，可以自行学习 */ protected override object VisitConstructor(ConstructorCallSite constructorCallSite, ILEmitResolverBuilderContext argument) { foreach (var parameterCallSite in constructorCallSite.ParameterCallSites) { VisitCallSite(parameterCallSite, argument); } argument.Generator.Emit(OpCodes.Newobj, constructorCallSite.ConstructorInfo); return null; } private GeneratedMethod BuildTypeNoCache(ServiceCallSite callSite) { //动态创建方法 var dynamicMethod = new DynamicMethod("ResolveService", attributes : MethodAttributes.Public | MethodAttributes.Static, callingConvention : CallingConventions.Standard, returnType : typeof(object), parameterTypes : new [] { typeof(ILEmitResolverBuilderRuntimeContext), typeof(ServiceProviderEngineScope) }, owner : GetType(), skipVisibility : true); var info = ILEmitCallSiteAnalyzer.Instance.CollectGenerationInfo(callSite); var ilGenerator = dynamicMethod.GetILGenerator(info.Size); //创建方法体 var runtimeContext = GenerateMethodBody(callSite, ilGenerator); return new GeneratedMethod() { Lambda = (Func<ServiceProviderEngineScope, object>) dynamicMethod.CreateDelegate(typeof(Func<ServiceProviderEngineScope, object>), runtimeContext), Context = runtimeContext, DynamicMethod = dynamicMethod }; }
internal class ExpressionResolverBuilder : CallSiteVisitor<object, Expression> { protected override Expression VisitConstructor(ConstructorCallSite callSite, object context) { var parameters = callSite.ConstructorInfo.GetParameters(); Expression[] parameterExpressions; if (callSite.ParameterCallSites.Length == 0) { parameterExpressions = Array.Empty<Expression>(); } else { //循环每一个参数，根据参数创建表达式 parameterExpressions = new Expression[callSite.ParameterCallSites.Length]; for (int i = 0; i < parameterExpressions.Length; i++) { parameterExpressions[i] = Convert(VisitCallSite(callSite.ParameterCallSites[i], context), parameters[i].ParameterType); } } return Expression.New(callSite.ConstructorInfo, parameterExpressions); } }
.net core 轻量级容器 ServiceProvider 源码分析
原文：https://www.cnblogs.com/qianmingjun/p/11889704.html