.net core IOC 容器实现(四) -- CallSiteRuntimeResolver

上一节聊了一下 CallSite 是怎样生成的，这一节我们来看一下 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 的(也就是上一节的主要内容)，而剩下的两个则是对于 CallSite 的使用，也是这一节的主要内容。

RealizeService

我们先看一下 _engine.RealizeService 方法。

public override Func<ServiceProviderEngineScope, object?> RealizeService(ServiceCallSite callSite)
{                      
    return scope =>            
    {                
        var result = CallSiteRuntimeResolver.Instance.Resolve(callSite, scope);                       
        return result;            
    };        
}

我们可以发现最终调用的还是 CallSiteRuntimeResolver.Instance.Resolve 这个方法，所以其实归根结底对 CallSite 的调用其实最终就是一个地方，也就是这个 Resolve 方法。

CallSiteRuntimeResolver.Resolve

public object? Resolve(ServiceCallSite callSite, ServiceProviderEngineScope scope)
{
    // 如果在 root scope 范围里已经有缓存了，直接返回
    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 会根据 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
        // 可能其他地方已经生成了，在获取一下看看        
        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

观察以上方法，我们可以发现无论是 VisitRootCache还是VisitScopeCache 等等，最终都是调用 VisitCallSiteMain 这个方法来生成的实例。

protected virtual TResult VisitCallSiteMain(ServiceCallSite callSite, TArgument argument)
{
    //callSite.kind 是只读属性 ，在 GetCallSite 时确定，根据 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 方法，通过反射来构造实例，主要思路是拿到实例类型的构造函数，然后通过递归(调用VisitCallSite(见本文最上方))准备构造函数所需要的参数，最后调用 invoke 来生成实例。

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 (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) 委托(委托由开发者实现)
    return factoryCallSite.Factory(context.Scope);
}

VisitIEnumerable

protected override object VisitIEnumerable(IEnumerableCallSite enumerableCallSite, RuntimeResolverContext context)
{
    //创建枚举类型的数组
    var array = Array.CreateInstance(
        enumerableCallSite.ItemType,
        enumerableCallSite.ServiceCallSites.Length);                            

    //给数组填充值
    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;        
}

总结

先根据实例的生命周期进行分支判断，接下来根据服务的生成方式进行分支判断。