[Asp.net 5] DependencyInjection项目代码分析4-微软的实现（4）

[Asp.net 5] DependencyInjection项目代码分析

public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain) {  ConstructorInfo[] constructors = _descriptor.ImplementationType.GetTypeInfo()   .DeclaredConstructors   .Where(IsInjectable)   .ToArray();  // TODO: actual service-fulfillment constructor selection  if (constructors.Length == 1)  {   ParameterInfo[] parameters = constructors[0].GetParameters();   IServiceCallSite[] parameterCallSites = new IServiceCallSite[parameters.Length];   for (var index = 0; index != parameters.Length; ++index)   {    parameterCallSites[index] = provider.GetServiceCallSite(parameters[index].ParameterType, callSiteChain);    if (parameterCallSites[index] == null && parameters[index].HasDefaultValue)    {     parameterCallSites[index] = new ConstantCallSite(parameters[index].DefaultValue);    }    if (parameterCallSites[index] == null)    {     throw new InvalidOperationException(Resources.FormatCannotResolveService(       parameters[index].ParameterType,        _descriptor.ImplementationType));    }   }   return new ConstructorCallSite(constructors[0], parameterCallSites);  }  return new CreateInstanceCallSite(_descriptor); } 

internal IServiceCallSite GetServiceCallSite(Type serviceType, ISet<Type> callSiteChain) {  try  {   if (callSiteChain.Contains(serviceType))   {    throw new InvalidOperationException(Resources.FormatCircularDependencyException(serviceType));   }   callSiteChain.Add(serviceType);   ServiceEntry entry;   if (_table.TryGetEntry(serviceType, out entry))   {    return GetResolveCallSite(entry.Last, callSiteChain);   }   object emptyIEnumerableOrNull = GetEmptyIEnumerableOrNull(serviceType);   if (emptyIEnumerableOrNull != null)   {    return new EmptyIEnumerableCallSite(serviceType, emptyIEnumerableOrNull);   }   return null;  }  finally  {   callSiteChain.Remove(serviceType);  } } internal IServiceCallSite GetResolveCallSite(IService service, ISet<Type> callSiteChain) {  IServiceCallSite serviceCallSite = service.CreateCallSite(this, callSiteChain);  if (service.Lifetime == ServiceLifetime.Transient)  {   return new TransientCallSite(serviceCallSite);  }  else if (service.Lifetime == ServiceLifetime.Scoped)  {   return new ScopedCallSite(service, serviceCallSite);  }  else  {   return new SingletonCallSite(service, serviceCallSite);  } } 

private class EmptyIEnumerableCallSite : IServiceCallSite {  private readonly object _serviceInstance;  private readonly Type _serviceType;  public EmptyIEnumerableCallSite(Type serviceType, object serviceInstance)  {   _serviceType = serviceType;   _serviceInstance = serviceInstance;  }  public object Invoke(ServiceProvider provider)  {   return _serviceInstance;  }  public Expression Build(Expression provider)  {   return Expression.Constant(_serviceInstance, _serviceType);  } } private class TransientCallSite : IServiceCallSite {  private readonly IServiceCallSite _service;  public TransientCallSite(IServiceCallSite service)  {   _service = service;  }  public object Invoke(ServiceProvider provider)  {   return provider.CaptureDisposable(_service.Invoke(provider));  }  public Expression Build(Expression provider)  {   return Expression.Call(    provider,    CaptureDisposableMethodInfo,    _service.Build(provider));  } } private class ScopedCallSite : IServiceCallSite {  private readonly IService _key;  private readonly IServiceCallSite _serviceCallSite;  public ScopedCallSite(IService key, IServiceCallSite serviceCallSite)  {   _key = key;   _serviceCallSite = serviceCallSite;  }  public virtual object Invoke(ServiceProvider provider)  {   object resolved;   lock (provider._sync)   {    if (!provider._resolvedServices.TryGetValue(_key, out resolved))    {     resolved = provider.CaptureDisposable(_serviceCallSite.Invoke(provider));     provider._resolvedServices.Add(_key, resolved);    }   }   return resolved;  }  public virtual Expression Build(Expression providerExpression)  {   var keyExpression = Expression.Constant(    _key,    typeof(IService));   var resolvedExpression = Expression.Variable(typeof(object), "resolved");   var resolvedServicesExpression = Expression.Field(    providerExpression,    "_resolvedServices");   var tryGetValueExpression = Expression.Call(    resolvedServicesExpression,    TryGetValueMethodInfo,    keyExpression,    resolvedExpression);   var captureDisposableExpression = Expression.Assign(    resolvedExpression,    Expression.Call(     providerExpression,     CaptureDisposableMethodInfo,     _serviceCallSite.Build(providerExpression)));   var addValueExpression = Expression.Call(    resolvedServicesExpression,    AddMethodInfo,    keyExpression,    resolvedExpression);   var blockExpression = Expression.Block(    typeof(object),    new[] { resolvedExpression },    Expression.IfThen(     Expression.Not(tryGetValueExpression),     Expression.Block(captureDisposableExpression, addValueExpression)),    resolvedExpression);   return Lock(providerExpression, blockExpression);  }  private static Expression Lock(Expression providerExpression, Expression body)  {   // The C# compiler would copy the lock object to guard against mutation.   // We don't, since we know the lock object is readonly.   var syncField = Expression.Field(providerExpression, "_sync");   var lockWasTaken = Expression.Variable(typeof(bool), "lockWasTaken");   var monitorEnter = Expression.Call(MonitorEnterMethodInfo, syncField, lockWasTaken);   var monitorExit = Expression.Call(MonitorExitMethodInfo, syncField);   var tryBody = Expression.Block(monitorEnter, body);   var finallyBody = Expression.IfThen(lockWasTaken, monitorExit);   return Expression.Block(    typeof(object),    new[] { lockWasTaken },    Expression.TryFinally(tryBody, finallyBody));  } } private class SingletonCallSite : ScopedCallSite {  public SingletonCallSite(IService key, IServiceCallSite serviceCallSite) : base(key, serviceCallSite)  {  }  public override object Invoke(ServiceProvider provider)  {   return base.Invoke(provider._root);  }  public override Expression Build(Expression provider)  {   return base.Build(Expression.Field(provider, "_root"));  } }