.net core 轻量级容器 ServiceProvider 源码分析

首先看 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 = ;

    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 - ];

        }

    }

    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 = ; 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 == )

    {

        //如果没有获取到公共的构造函数会抛出异常

        throw new InvalidOperationException(Resources.FormatNoConstructorMatch(implementationType));

    }

    else if (constructors.Length == )

    {

        //当只有一个构造函数时，优化处理逻辑

        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 = ; 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 == )

        {

            parameterValues = Array.Empty<object>();

        }

        else

        {

            //循环获取每个参数类型的实例，如果参数类型还依赖于其它的类型，则会递归获取

            parameterValues = new object[constructorCallSite.ParameterCallSites.Length];

            for (var index = ; 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 == )

        {

            parameterExpressions = Array.Empty<Expression>();

        }

        else

        {

            //循环每一个参数，根据参数创建表达式

            parameterExpressions = new Expression[callSite.ParameterCallSites.Length];

            for (int i = ; i < parameterExpressions.Length; i++)

            {

                parameterExpressions[i] = Convert(VisitCallSite(callSite.ParameterCallSites[i], context), parameters[i].ParameterType);

            }

        }

        return Expression.New(callSite.ConstructorInfo, parameterExpressions);

    }

}

总结一下
1. ServiceCollection 只不过是用来定义 Service 的类型和定义以及生命周期
2. Service 类型的创建是最终是通过不同的 RuntimeResolver 来实现的
3. 源码中还包含大量对缓存的使用，如果没有缓存，这个容器的效率也就太低了，我在分析源码的时候直接略过了，原因是，我觉得缓存一定是在先实现后的基础上再加的，所以我们研究源码的过程中可以先忽略这些缓存的使用
4. 关于 Service 的生命周期我没有细讲，单例和瞬时都非常好理解，其实最复杂的就是 Scope，有点绕的地方在于维护 IDisposable 类型的资源的释放，当然这个理解起来也不是很难，有兴趣的小伙伴可以自行研究
5. 源码分析没有讲最基本的 IOC 概念和容器概念，想要理解这些，前提是要对容器的概念非常了解才行

巴特西

.net core 轻量级容器 ServiceProvider 源码分析

最新文章

热门文章