public interface IServiceCollection : 
    IList<ServiceDescriptor>,
    ICollection<ServiceDescriptor>,
    IEnumerable<ServiceDescriptor>,
    IEnumerable;

builder.Services.AddTransient<StudentService>();
builder.Services.AddKeyedTransient<IStudentRepository, StudentRepository>("a");
builder.Services.AddKeyedTransient<IStudentRepository, StudentRepository2>("b");
builder.Services.AddTransient<TransientService>();
builder.Services.AddScoped<ScopeService>();
builder.Services.AddSingleton<SingletonService>();

public interface IServiceProvider
{
  object? GetService(Type serviceType);
}

public object? GetService(Type serviceType) => GetService(ServiceIdentifier.FromServiceType(serviceType), Root);

internal object? GetService(ServiceIdentifier serviceIdentifier, ServiceProviderEngineScope serviceProviderEngineScope)
{
    if (_disposed)
    {
        ThrowHelper.ThrowObjectDisposedException();
    }
    // 獲取服務(wù)標(biāo)識(shí)符對(duì)應(yīng)的服務(wù)訪問(wèn)器
    ServiceAccessor serviceAccessor = _serviceAccessors.GetOrAdd(serviceIdentifier, _createServiceAccessor);
    // 執(zhí)行解析時(shí)的hock
    OnResolve(serviceAccessor.CallSite, serviceProviderEngineScope);
    DependencyInjectionEventSource.Log.ServiceResolved(this, serviceIdentifier.ServiceType);
    // 通過(guò)服務(wù)訪問(wèn)器提供的解析服務(wù)，得到服務(wù)實(shí)例
    object? result = serviceAccessor.RealizedService?.Invoke(serviceProviderEngineScope);
    System.Diagnostics.Debug.Assert(result is null || CallSiteFactory.IsService(serviceIdentifier));
    return result;
}

internal readonly struct ServiceIdentifier : IEquatable<ServiceIdentifier>
{
    public object? ServiceKey { get; }
    public Type ServiceType { get; }
}

private ServiceAccessor CreateServiceAccessor(ServiceIdentifier serviceIdentifier)
{
    // 通過(guò) CallSiteFactory 獲取服務(wù)的調(diào)用點(diǎn)（CallSite），這是服務(wù)解析的一個(gè)表示形式。
    ServiceCallSite? callSite = CallSiteFactory.GetCallSite(serviceIdentifier, new CallSiteChain());
    // 如果調(diào)用站點(diǎn)不為空，則繼續(xù)構(gòu)建服務(wù)訪問(wèn)器。
    if (callSite != null)
    {
        DependencyInjectionEventSource.Log.CallSiteBuilt(this, serviceIdentifier.ServiceType, callSite);
        // 觸發(fā)創(chuàng)建調(diào)用站點(diǎn)的相關(guān)事件。
        OnCreate(callSite);
        // 如果調(diào)用站點(diǎn)的緩存位置是根（Root），即表示這是一個(gè)單例服務(wù)。
        if (callSite.Cache.Location == CallSiteResultCacheLocation.Root)
        {
            // 直接拿緩存內(nèi)容
            object? value = CallSiteRuntimeResolver.Instance.Resolve(callSite, Root);
            return new ServiceAccessor { CallSite = callSite, RealizedService = scope => value };
        }
        // 通過(guò)引擎解析
        Func<ServiceProviderEngineScope, object?> realizedService = _engine.RealizeService(callSite);
        return new ServiceAccessor { CallSite = callSite, RealizedService = realizedService };
    }
    // 如果調(diào)用點(diǎn)為空，則它的實(shí)現(xiàn)服務(wù)函數(shù)總是返回 null。
    return new ServiceAccessor { CallSite = callSite, RealizedService = _ => null };
}

        private ServiceProviderEngine GetEngine()
        {
            ServiceProviderEngine engine;
#if NETFRAMEWORK || NETSTANDARD2_0
            engine = CreateDynamicEngine();
#else
            if (RuntimeFeature.IsDynamicCodeCompiled && !DisableDynamicEngine)
            {
                engine = CreateDynamicEngine();
            }
            else
            {
                // Don't try to compile Expressions/IL if they are going to get interpreted
                engine = RuntimeServiceProviderEngine.Instance;
            }
#endif
            return engine;
            [UnconditionalSuppressMessage("AotAnalysis", "IL3050:RequiresDynamicCode",
                Justification = "CreateDynamicEngine won't be called when using NativeAOT.")] // see also https://github.com/dotnet/linker/issues/2715
            ServiceProviderEngine CreateDynamicEngine() => new DynamicServiceProviderEngine(this);
        }

public override Func<ServiceProviderEngineScope, object?> RealizeService(ServiceCallSite callSite)
{
    // 定義一個(gè)局部變量來(lái)跟蹤委托被調(diào)用的次數(shù)
    int callCount = 0;
    return scope =>
    {
        // 當(dāng)委托被調(diào)用時(shí)，先使用CallSiteRuntimeResolver.Instance.Resolve方法來(lái)解析服務(wù)。這是一個(gè)同步操作，確保在編譯優(yōu)化之前，服務(wù)可以被正常解析。
        var result = CallSiteRuntimeResolver.Instance.Resolve(callSite, scope);
        // 委托第二次被調(diào)用，通過(guò)UnsafeQueueUserWorkItem在后臺(tái)線程上啟動(dòng)編譯優(yōu)化
        if (Interlocked.Increment(ref callCount) == 2)
        {
            // 將一個(gè)工作項(xiàng)排隊(duì)到線程池，但不捕獲當(dāng)前的執(zhí)行上下文。
            _ = ThreadPool.UnsafeQueueUserWorkItem(_ =>
            {
                try
                {
                    // 用編譯優(yōu)化后的委托替換當(dāng)前的服務(wù)訪問(wèn)器，主要用到emit/expression技術(shù)
                    _serviceProvider.ReplaceServiceAccessor(callSite, base.RealizeService(callSite));
                }
                catch (Exception ex)
                {
                    DependencyInjectionEventSource.Log.ServiceRealizationFailed(ex, _serviceProvider.GetHashCode());
                    Debug.Fail($"We should never get exceptions from the background compilation.{Environment.NewLine}{ex}");
                }
            },
            null);
        }
        return result;
    };
}

internal sealed class ServiceProviderEngineScope : IServiceScope, IServiceProvider, IKeyedServiceProvider, 			IAsyncDisposable, IServiceScopeFactory
{
    // this scope中所有實(shí)現(xiàn)IDisposable or IAsyncDisposable的服務(wù)
    private List<object>? _disposables;
    // 解析過(guò)的服務(wù)緩存（其實(shí)就是scope生命周期的服務(wù)緩存，singleton生命周期的服務(wù)緩存都直接掛在調(diào)用點(diǎn)上了）
    internal Dictionary<ServiceCacheKey, object?> ResolvedServices { get; }
    // 實(shí)錘服務(wù)商代言人
    public IServiceProvider ServiceProvider => this;
    // 沒(méi)錯(cuò)啦，通過(guò)root scope我們又能繼續(xù)創(chuàng)建無(wú)數(shù)個(gè)scope，他們彼此獨(dú)立
    public IServiceScope CreateScope() => RootProvider.CreateScope();
}

public object? GetService(Type serviceType)
{
    if (_disposed)
    {
        ThrowHelper.ThrowObjectDisposedException();
    }
    return RootProvider.GetService(ServiceIdentifier.FromServiceType(serviceType), this);
}

internal object? CaptureDisposable(object? service)
{
    // 如果服務(wù)沒(méi)有實(shí)現(xiàn) IDisposable or IAsyncDisposable，那么不需要捕獲，直接原路返回
    if (ReferenceEquals(this, service) || !(service is IDisposable || service is IAsyncDisposable))
    {
        return service;
    }
    bool disposed = false;
    lock (Sync)
    {
        if (_disposed) // 如果scope已經(jīng)銷毀則進(jìn)入銷毀流程
        {
            disposed = true;
        }
        else
        {
            _disposables ??= new List<object>();
            _disposables.Add(service);
        }
    }
    // Don't run customer code under the lock
    if (disposed) // 這表示我們?cè)谠噲D捕獲可銷毀服務(wù)時(shí)，scope就已經(jīng)被銷毀
    {
        if (service is IDisposable disposable)
        {
            disposable.Dispose();
        }
        else
        {
            // sync over async, for the rare case that an object only implements IAsyncDisposable and may end up starving the thread pool.
            object? localService = service; // copy to avoid closure on other paths
            Task.Run(() => ((IAsyncDisposable)localService).DisposeAsync().AsTask()).GetAwaiter().GetResult();
        }
        // 這種case會(huì)拋出一個(gè)ObjectDisposedException
        ThrowHelper.ThrowObjectDisposedException();
    }
    return service;
}

public ValueTask DisposeAsync()
{
    List<object>? toDispose = BeginDispose(); // 獲取_disposable
    if (toDispose != null)
    {
        // 從后往前，依次銷毀服務(wù)
    }
}

if (IsRootScope && !RootProvider.IsDisposed()) RootProvider.Dispose();

internal abstract class ServiceCallSite
{
    protected ServiceCallSite(ResultCache cache)
	 {
	     Cache = cache;
	 }
    public abstract Type ServiceType { get; }
	 public abstract Type? ImplementationType { get; }
	 public abstract CallSiteKind Kind { get; }
	 public ResultCache Cache { get; }
	 public object? Value { get; set; }
	 public object? Key { get; set; }
	 public bool CaptureDisposable => ImplementationType == null ||
    	typeof(IDisposable).IsAssignableFrom(ImplementationType) ||
    	typeof(IAsyncDisposable).IsAssignableFrom(ImplementationType);
}

public CallSiteResultCacheLocation Location { get; set; } // 緩存位置
public ServiceCacheKey Key { get; set; } // 服務(wù)key（鍵化服務(wù)用的）

internal readonly struct ServiceCacheKey : IEquatable<ServiceCacheKey>
{
    public ServiceIdentifier ServiceIdentifier { get; }
    public int Slot { get; } // 那最后一個(gè)實(shí)現(xiàn)的slot是0
}

private ServiceCallSite? CreateCallSite(ServiceIdentifier serviceIdentifier, CallSiteChain callSiteChain)
{
    if (!_stackGuard.TryEnterOnCurrentStack()) // 防止棧溢出
    {
        return _stackGuard.RunOnEmptyStack(CreateCallSite, serviceIdentifier, callSiteChain);
    }
    // 獲取服務(wù)標(biāo)識(shí)符對(duì)應(yīng)的鎖，以確保在創(chuàng)建調(diào)用點(diǎn)時(shí)的線程安全。
    // 是為了保證并行解析下的調(diào)用點(diǎn)也只會(huì)被創(chuàng)建一次，例如：
    // C -> D -> A
    // E -> D -> A
    var callsiteLock = _callSiteLocks.GetOrAdd(serviceIdentifier, static _ => new object());
    lock (callsiteLock)
    {
        // 檢查當(dāng)前服務(wù)標(biāo)識(shí)符是否會(huì)導(dǎo)致循環(huán)依賴
        callSiteChain.CheckCircularDependency(serviceIdentifier);
        // 首先嘗試創(chuàng)建精確匹配的服務(wù)調(diào)用站點(diǎn)，如果失敗，則嘗試創(chuàng)建開放泛型服務(wù)調(diào)用站點(diǎn)，如果還是失敗，則嘗試創(chuàng)建枚舉服務(wù)調(diào)用站點(diǎn)。如果所有嘗試都失敗了，callSite將為null。
        ServiceCallSite? callSite = TryCreateExact(serviceIdentifier, callSiteChain) ??
                                   TryCreateOpenGeneric(serviceIdentifier, callSiteChain) ??
                                   TryCreateEnumerable(serviceIdentifier, callSiteChain);
        return callSite;
    }
}

protected virtual TResult VisitCallSite(ServiceCallSite callSite, TArgument argument)
{
    if (!_stackGuard.TryEnterOnCurrentStack()) // 一些校驗(yàn)，分棧啥的
    {
        return _stackGuard.RunOnEmptyStack(VisitCallSite, callSite, argument);
    }
    switch (callSite.Cache.Location)
    {
        case CallSiteResultCacheLocation.Root: // 單例
            return VisitRootCache(callSite, argument);
        case CallSiteResultCacheLocation.Scope: // 作用域
            return VisitScopeCache(callSite, argument);
        case CallSiteResultCacheLocation.Dispose: // 瞬態(tài)
            return VisitDisposeCache(callSite, argument);
        case CallSiteResultCacheLocation.None: // 不緩存（ConstantCallSite）
            return VisitNoCache(callSite, argument);
        default:
            throw new ArgumentOutOfRangeException();
    }
}

protected override object? VisitRootCache(ServiceCallSite callSite, RuntimeResolverContext context)
{
    if (callSite.Value is object value)
    {
        // Value already calculated, return it directly
        return value;
    }
    var lockType = RuntimeResolverLock.Root;
    // 單例都是直接放根作用域的
    ServiceProviderEngineScope serviceProviderEngine = context.Scope.RootProvider.Root;
    lock (callSite)
    {
        // 這里搞了個(gè)雙檢鎖來(lái)確保在多線程環(huán)境中，同一時(shí)間只有一個(gè)線程可以執(zhí)行接下來(lái)的代碼塊。
        // Lock the callsite and check if another thread already cached the value
        if (callSite.Value is object callSiteValue)
        {
            return callSiteValue;
        }
        object? resolved = VisitCallSiteMain(callSite, new RuntimeResolverContext
        {
            Scope = serviceProviderEngine,
            AcquiredLocks = context.AcquiredLocks | lockType
        });
        // 捕獲可銷毀的服務(wù)
        serviceProviderEngine.CaptureDisposable(resolved);
        // 緩存解析結(jié)果到調(diào)用點(diǎn)上
        callSite.Value = resolved;
        return resolved;
    }
}

protected virtual TResult VisitCallSiteMain(ServiceCallSite callSite, TArgument argument)
{
    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()));
    }
}

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++)
        {
            // 遞歸構(gòu)建依賴的服務(wù)
            parameterValues[index] = VisitCallSite(constructorCallSite.ParameterCallSites[index], context);
        }
    }
    // new (xxx)
    return constructorCallSite.ConstructorInfo.Invoke(BindingFlags.DoNotWrapExceptions, binder: null, parameters: parameterValues, culture: null);
}

protected override object? VisitScopeCache(ServiceCallSite callSite, RuntimeResolverContext context)
{
    // Check if we are in the situation where scoped service was promoted to singleton
    // and we need to lock the root
    return context.Scope.IsRootScope ?
        VisitRootCache(callSite, context) :
        VisitCache(callSite, context, context.Scope, RuntimeResolverLock.Scope);
}

internal object? GetService(ServiceIdentifier serviceIdentifier, ServiceProviderEngineScope serviceProviderEngineScope)

private object? VisitCache(ServiceCallSite callSite, RuntimeResolverContext context, ServiceProviderEngineScope serviceProviderEngine
{
    bool lockTaken = false;
    object sync = serviceProviderEngine.Sync;
    Dictionary<ServiceCacheKey, object?> resolvedServices = serviceProviderEngine.ResolvedServices;
    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;
        }
        // scope服務(wù)的解析結(jié)果是放在engine scope的ResolvedServices上的，而非調(diào)用點(diǎn)
        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);
        }
    }
}

protected override object? VisitDisposeCache(ServiceCallSite transientCallSite, RuntimeResolverContext context)
{
    return context.Scope.CaptureDisposable(VisitCallSiteMain(transientCallSite, context));
}