上一節(jié)聊了一下 CallSite 是怎樣生成的，這一節(jié)我們來看一下 CallSite 是如何使用的。
入口
先讓我們來回顧一下 CreateServiceAccessor 這個方法。
private Func<ServiceProviderEngineScope, object?> CreateServiceAccessor(Type serviceType)
{
//通過 服務類型 獲取 callSite
ServiceCallSite? callSite = CallSiteFactory.GetCallSite(serviceType, new CallSiteChain());
if (callSite != null)
{
if (callSite.Cache.Location == CallSiteResultCacheLocation.Root)
{
//直接解析
object? value = CallSiteRuntimeResolver.Instance.Resolve(callSite, Root);
}
return _engine.RealizeService(callSite);
}
}
這段代碼跟 CallSite 有關的一共有三個地方，分別是 GetCallSite 和 Resolve(callSite,Root)以及 _engine.RealizeService。其中 GetCallSite 是用來生成 CallSite 的(也就是上一節(jié)的主要內容)，而剩下的兩個則是對于 CallSite 的使用，也是這一節(jié)的主要內容。
RealizeService
我們先看一下 _engine.RealizeService 方法。
public override Func<ServiceProviderEngineScope, object?> RealizeService(ServiceCallSite callSite)
{
return scope =>
{
var result = CallSiteRuntimeResolver.Instance.Resolve(callSite, scope);
return result;
};
}
我們可以發(fā)現(xiàn)最終調用的還是 CallSiteRuntimeResolver.Instance.Resolve 這個方法，所以其實歸根結底對 CallSite 的調用其實最終就是一個地方，也就是這個 Resolve 方法。
CallSiteRuntimeResolver.Resolve
public object? Resolve(ServiceCallSite callSite, ServiceProviderEngineScope scope)
{
// 如果在 root scope 范圍里已經(jīng)有緩存了，直接返回
if (scope.IsRootScope && callSite.Value is object cached)
{
return cached;
}
//調用 VisitCallSite 進行解析
return VisitCallSite(callSite, new RuntimeResolverContext
{
Scope = scope
});
}
VisitCallSite
protected virtual TResult VisitCallSite(ServiceCallSite callSite, TArgument argument)
{
switch (callSite.Cache.Location)
{
case CallSiteResultCacheLocation.Root:
return VisitRootCache(callSite, argument);
case CallSiteResultCacheLocation.Scope:
return VisitScopeCache(callSite, argument);
case CallSiteResultCacheLocation.Dispose:
return VisitDisposeCache(callSite, argument);
case CallSiteResultCacheLocation.None:
return VisitNoCache(callSite, argument);
default:
throw new ArgumentOutOfRangeException();
}
}
VisitCallSite 會根據(jù) Location 進行分支處理，Location 是 CallSite 里的一個屬性。其中 Root 對應 Singleton，Scope 對應 Scope 生命周期，Dispose 對應 Trasient，None可以先將其理解為Singleton。
VisitRootCache(Single)
protected override object? VisitRootCache(ServiceCallSite callSite, RuntimeResolverContext context)
{
// Singleton 懶加載 如果有 value 直接返回
if (callSite.Value is object value)
{
// Value already calculated, return it directly
return value;
}
var lockType = RuntimeResolverLock.Root;
//在 root 范圍進行解析
ServiceProviderEngineScope serviceProviderEngine = context.Scope.RootProvider.Root;
// 鎖住 callSite 防止重復生成value
lock (callSite)
{
// Lock the callsite and check if another thread already cached the value
// 可能其他地方已經(jīng)生成了，在獲取一下看看
if (callSite.Value is object callSiteValue)
{
return callSiteValue;
}
//最終依舊是調用了 VisitCallSiteMain 方法
object? resolved = VisitCallSiteMain(callSite, new RuntimeResolverContext
{
Scope = serviceProviderEngine,
AcquiredLocks = context.AcquiredLocks | lockType
});
serviceProviderEngine.CaptureDisposable(resolved);
//進行緩存
callSite.Value = resolved;
return resolved;
}
}
VisitScopeCache(Scope)
// Check if we are in the situation where scoped service was promoted to singleton
// and we need to lock the root
// Scope 依賴 Singleton
return context.Scope.IsRootScope ?
VisitRootCache(callSite, context) :
VisitCache(callSite, context, context.Scope, RuntimeResolverLock.Scope);
private object? VisitCache(
ServiceCallSite callSite,
RuntimeResolverContext context,
ServiceProviderEngineScope serviceProviderEngine,
RuntimeResolverLock lockType)
{
bool lockTaken = false;
object sync = serviceProviderEngine.Sync;
// Dictionary<ServiceCacheKey, object?> ResolvedServices { get; } 緩存
Dictionary<ServiceCacheKey, object?> resolvedServices = serviceProviderEngine.ResolvedServices;
// Taking locks only once allows us to fork resolution process
// on another thread without causing the deadlock because we
// always know that we are going to wait the other thread to finish before
// releasing the lock
// 鎖住 sync 對象
if ((context.AcquiredLocks & lockType) == 0)
{
Monitor.Enter(sync, ref lockTaken);
}
try
{
//獲取鎖之后
// Note: This method has already taken lock by the caller for resolution and access synchronization.
// For scoped: takes a dictionary as both a resolution lock and a dictionary access lock.
//先訪問緩存
if (resolvedServices.TryGetValue(callSite.Cache.Key, out object? resolved))
{
return resolved;
}
//解析
resolved = VisitCallSiteMain(callSite, new RuntimeResolverContext
{
Scope = serviceProviderEngine,
AcquiredLocks = context.AcquiredLocks | lockType
});
//緩存需要釋放的實例
serviceProviderEngine.CaptureDisposable(resolved);
//放入緩存
resolvedServices.Add(callSite.Cache.Key, resolved);
return resolved;
}
finally
{
//解鎖
if (lockTaken)
{
Monitor.Exit(sync);
}
}
}
VisitDisposeCache(Transient)
protected override object? VisitDisposeCache(ServiceCallSite transientCallSite, RuntimeResolverContext context)
{
//解析
var instance=VisitCallSiteMain(transientCallSite, context);
return context.Scope.CaptureDisposable(instance);
}
VisitNoCache(None)
protected virtual TResult VisitNoCache(ServiceCallSite callSite, TArgument argument)
{
return VisitCallSiteMain(callSite, argument);
}
VisitCallSiteMain
觀察以上方法，我們可以發(fā)現(xiàn)無論是 VisitRootCache還是VisitScopeCache 等等，最終都是調用 VisitCallSiteMain 這個方法來生成的實例。
protected virtual TResult VisitCallSiteMain(ServiceCallSite callSite, TArgument argument)
{
//callSite.kind 是只讀屬性 ，在 GetCallSite 時確定，根據(jù) CallSite 類型確定(例 ConstantCallSite)
switch (callSite.Kind)
{
case CallSiteKind.Factory:
return VisitFactory((FactoryCallSite)callSite, argument);
case CallSiteKind.IEnumerable:
return VisitIEnumerable((IEnumerableCallSite)callSite, argument);
case CallSiteKind.Constructor:
return VisitConstructor((ConstructorCallSite)callSite, argument);
case CallSiteKind.Constant:
return VisitConstant((ConstantCallSite)callSite, argument);
case CallSiteKind.ServiceProvider:
return VisitServiceProvider((ServiceProviderCallSite)callSite, argument);
default:
throw new NotSupportedException(SR.Format(SR.CallSiteTypeNotSupported, callSite.GetType()));
}
}
VisitConstructor
其中比較復雜的就是這個 VisitConstructor 方法，通過反射來構造實例，主要思路是拿到實例類型的構造函數(shù)，然后通過遞歸(調用VisitCallSite(見本文最上方))準備構造函數(shù)所需要的參數(shù)，最后調用 invoke 來生成實例。文章來源：http://www.zghlxwxcb.cn/news/detail-600637.html
protected override object VisitConstructor(ConstructorCallSite constructorCallSite, RuntimeResolverContext context)
{
object?[] parameterValues;
//獲取構造需要使用的參數(shù)
//無參
if (constructorCallSite.ParameterCallSites.Length == 0)
{
parameterValues = Array.Empty<object>();
}
//有參
else
{
parameterValues = new object?[constructorCallSite.ParameterCallSites.Length];
for (int index = 0; index < parameterValues.Length; index++)
{
//遞歸解析 VisitCallSite 見上文
parameterValues[index] = VisitCallSite(constructorCallSite.ParameterCallSites[index], context);
}
}
#if NETFRAMEWORK || NETSTANDARD2_0
try
{
return constructorCallSite.ConstructorInfo.Invoke(parameterValues);
}
catch (Exception ex) when (ex.InnerException != null)
{
ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
// The above line will always throw, but the compiler requires we throw explicitly.
throw;
}
#else
return constructorCallSite.ConstructorInfo.Invoke(BindingFlags.DoNotWrapExceptions, binder: null,
parameters: parameterValues, culture: null);
#endif
}
VisitFactory
protected override object VisitFactory(FactoryCallSite factoryCallSite, RuntimeResolverContext context)
{
//調用 Factory(Func<IServiceProvider, object> Factory) 委托(委托由開發(fā)者實現(xiàn))
return factoryCallSite.Factory(context.Scope);
}
VisitIEnumerable
protected override object VisitIEnumerable(IEnumerableCallSite enumerableCallSite, RuntimeResolverContext context)
{
//創(chuàng)建枚舉類型的數(shù)組
var array = Array.CreateInstance(
enumerableCallSite.ItemType,
enumerableCallSite.ServiceCallSites.Length);
//給數(shù)組填充值
for (int index = 0; index < enumerableCallSite.ServiceCallSites.Length; index++)
{
object? value = VisitCallSite(enumerableCallSite.ServiceCallSites[index], context);
array.SetValue(value, index);
}
return array;
}
VisitConstant
protected override object? VisitConstant(ConstantCallSite constantCallSite, RuntimeResolverContext context)
{
//直接返回保存的實例
return constantCallSite.DefaultValue;
}
VisitServiceProvider
protected override object VisitServiceProvider(ServiceProviderCallSite serviceProviderCallSite, RuntimeResolverContext context)
{
return context.Scope;
}
總結
先根據(jù)實例的生命周期進行分支判斷，接下來根據(jù)服務的生成方式進行分支判斷。
文章來源地址http://www.zghlxwxcb.cn/news/detail-600637.html
到了這里，關于.net core IOC 容器實現(xiàn)(四) -- CallSiteRuntimeResolver的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！
