- 首先看 ServiceCollection 的定義
//定義 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); } }
- ServiceProvider，Service 的提供者，這是一個非常重要的類，也是容器的核心，主要用來創建 Service 物件的實體
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，下面是他們之間的關系，
- 由上圖可知，ServiceProvider 的最終的核心實作應該在 ServiceProviderEngine 這個抽象類中，下面我們來看一下這個類，我去掉了一些判斷和記錄日志的邏輯，讓代碼看起來更簡潔
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); } }這個類中有幾個特別重要的物件，
- RuntimeResolver ，Service 物件的創建就是這個物件完成的，當然不同的子類，有不同的實作，
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> 的泛型類，只是對應的泛型引數不太一樣
- CallSiteFactory，呼叫目標工廠，主要用來根據 ServiceDescriptor 的定義創建對應的 ServiceCallSite 物件，然后根據該物件來創建 Service 的實體，這個物件比較復雜，下面來看一些簡潔的原始碼
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); }
- RuntimeResolver ，Service 物件的創建就是這個物件完成的，當然不同的子類，有不同的實作，
-
由于 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); } }
- ILEmitResolverBuilder (.net core 默認使用方式)
/* 由于 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 }; }
- ExpressionResolverBuilder 可以理解為使用運算式樹將 CallSiteRuntimeResolver 的代碼翻譯了一遍
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); } }
-
- 總結一下
- ServiceCollection 只不過是用來定義 Service 的型別和定義以及生命周期
- Service 型別的創建是最終是通過不同的 RuntimeResolver 來實作的
- 原始碼中還包含大量對快取的使用，如果沒有快取，這個容器的效率也就太低了，我在分析原始碼的時候直接略過了，原因是，我覺得快取一定是在先實作后的基礎上再加的，所以我們研究原始碼的程序中可以先忽略這些快取的使用
- 關于 Service 的生命周期我沒有細講，單例和瞬時都非常好理解，其實最復雜的就是 Scope，有點繞的地方在于維護 IDisposable 型別的資源的釋放，當然這個理解起來也不是很難，有興趣的小伙伴可以自行研究
- 原始碼分析沒有講最基本的 IOC 概念和容器概念，想要理解這些，前提是要對容器的概念非常了解才行
轉載請註明出處，本文鏈接：https://www.uj5u.com/net/61638.html
標籤：.NET Core