/// <summary> /// /// </summary> public MultiEfRepository() { Type t = typeof(T); lock (t) { Service service = null; if (s_EntityKeyedServices.ContainsKey(t)) { service = s_EntityKeyedServices[t]; } else { var contextKeyAttribute = t.GetCustomAttribute <EntityContextKeyAttribute>(); if (contextKeyAttribute == null || contextKeyAttribute.ContextKey.IsEmpty()) { service = new TypedService(t); } else { service = new KeyedService(contextKeyAttribute.ContextKey, t); } s_EntityKeyedServices.Add(t, service); } _context = EngineContext.Current.ContainerManager.ResolveService <IChenyuanDBContext>(service); } }
private Func <object> GetFactory(Type type) { BuildScopeIfRequired(); Func <object> factory; if (!SimpleCache.TryGetValue(type, out factory) && !ServiceCache.TryGetValue(type, out factory)) { var serv = new TypedService(type); IComponentRegistration reg; var inContainer = CurrentScope.ComponentRegistry.TryGetRegistration(serv, out reg); RegistrationCache.TryAdd(type, inContainer); if (inContainer) { factory = CurrentScope.ResolveLookup(serv, reg, new Parameter[0]).Factory; SimpleCache.TryAdd(type, factory); } else { factory = BuildFactoryForService(type); ServiceCache.TryAdd(type, factory); } } return(factory); }
RegisterCollection <T>(ContainerBuilder builder, string collectionName, Type elementType) { if (builder == null) { throw new ArgumentNullException("builder"); } if (elementType == null) { throw new ArgumentNullException("elementType"); } Enforce.ArgumentNotNullOrEmpty(collectionName, "collectionName"); var arrayType = elementType.MakeArrayType(); var ts = new TypedService(elementType); var activator = new DelegateActivator(arrayType, (c, p) => { var elements = GetElementRegistrations(collectionName, c.ComponentRegistry); var items = elements.Select(e => c.ResolveComponent(ts, e, p)).ToArray(); var result = Array.CreateInstance(elementType, items.Length); items.CopyTo(result, 0); return(result); }); var rb = new RegistrationBuilder <T[], SimpleActivatorData, SingleRegistrationStyle>( new TypedService(typeof(T[])), new SimpleActivatorData(activator), new SingleRegistrationStyle()); builder.RegisterCallback(cr => RegistrationBuilder.RegisterSingleComponent(cr, rb)); return(rb); }
public void AfterResolvingAdapter_AddingMoreAdaptees_AddsMoreAdapters() { var registryBuilder = Factory.CreateEmptyComponentRegistryBuilder(); registryBuilder.AddRegistrationSource(new MetaRegistrationSource()); var metaService = new TypedService(typeof(Meta <object>)); var first = RegistrationBuilder.ForType <object>().CreateRegistration(); registryBuilder.Register(first); using (var container = new Container(registryBuilder.Build())) { var meta1 = container.ComponentRegistry.RegistrationsFor(metaService); Assert.Single(meta1); var second = RegistrationBuilder.ForType <object>().CreateRegistration(); using (var lifetimeScope = container.BeginLifetimeScope(builder => builder.ComponentRegistryBuilder.Register(second))) { var meta2 = lifetimeScope.ComponentRegistry.RegistrationsFor(metaService); Assert.Equal(2, meta2.Count()); } } }
public void IgnoresTypesThatShouldNotBeProvided(Type serviceType) { var source = new AnyConcreteTypeNotAlreadyRegisteredSource(); var service = new TypedService(serviceType); Assert.False(source.RegistrationsFor(service, s => Enumerable.Empty <IComponentRegistration>()).Any(), $"Failed: {serviceType}"); }
/// <summary> /// Creates the controller. /// </summary> /// <param name="context">The context.</param> /// <param name="controllerType">Type of the controller.</param> /// <returns>The controller.</returns> protected override IController GetControllerInstance(RequestContext context, Type controllerType) { if (context == null) { throw new ArgumentNullException("context"); } // a null controller type is a 404, because the base class couldn't resolve the controller name back to a type // a common example of this case would be a non-existant favicon.ico if (controllerType == null) { throw new HttpException(404, string.Format("controller type was not found for path {0}", context.HttpContext.Request.Path)); } var controllerService = new TypedService(controllerType); object controller; if (_containerProvider.RequestLifetime.TryResolveService(controllerService, out controller)) { return((IController)controller); } throw new HttpException(404, string.Format(AutofacControllerFactoryResources.NotFound, controllerService, controllerType.FullName, context.HttpContext.Request.Path)); }
private object CreateMock(IComponentContext context, TypedService typedService) { var mock = Mock.Create(typedService.ServiceType); this.mocks.Add(mock); return(mock); }
/// <summary> /// Creates a mock object. /// </summary> /// <param name="context">The component context.</param> /// <param name="typedService">The typed service.</param> /// <returns> /// The mock object from the repository. /// </returns> private object CreateMock(IComponentContext context, TypedService typedService) { var specificCreateMethod = this._createMethod.MakeGenericMethod(new[] { typedService.ServiceType }); var mock = (Mock)specificCreateMethod.Invoke(context.Resolve <MockRepository>(), null); return(mock.Object); }
/// <summary> /// Registers aggregation decorator (decorator that will broadcast all calls to all decorated instances) /// for the services of type <typeparamref name="TService" />. /// </summary> /// <typeparam name="TService">Type of the decorated services.</typeparam> /// <param name="builder">Container builder.</param> /// <param name="decoratorFactory">Factory delegate that can create new instances of the aggregate decorator.</param> /// <returns>Registration builder to continue the registration.</returns> public static IRegistrationBuilder <TService, SimpleActivatorData, SingleRegistrationStyle> RegisterAggregationDecorator <TService>( this ContainerBuilder builder, Func <IComponentContext, IEnumerable <TService>, TService> decoratorFactory) { Guard.NotNull("builder", builder); Guard.NotNull("decoratorFactory", decoratorFactory); var originalKey = Guid.NewGuid(); var registrationBuilder = RegistrationBuilder.ForDelegate((c, p) => decoratorFactory(c, c.ResolveKeyed <IEnumerable <TService> >(originalKey))).As <TService>(); builder.RegisterCallback(cr => { Guard.NotNull("componentRegistry", cr); var service = new TypedService(typeof(TService)); var originalRegistrations = cr.RegistrationsFor(service); // Register original component as keyed foreach (var originalRegistration in originalRegistrations) { cr.Register(RegistrationBuilder.CreateRegistration( Guid.NewGuid(), CopyRegistrationData(originalRegistration), originalRegistration.Activator, new[] { new KeyedService(originalKey, typeof(TService)) })); } // Override default registration with decorator RegistrationBuilder.RegisterSingleComponent <TService, SimpleActivatorData, SingleRegistrationStyle>(cr, registrationBuilder); }); return(registrationBuilder); }
public void ChangeType_ProvidesTypedServiceWithNewType() { var nt = typeof(string); var ts = new TypedService(typeof(object)); var n = ts.ChangeType(nt); Assert.Equal(new TypedService(nt), n); }
public void SetUp() { _modelMapper = new ModelMapper(); TypeModel unused; _modelMapper.GetOrAddTypeModel(typeof(string), out unused); _service = new TypedService(typeof(string)); _mapped = _modelMapper.GetServiceModel(_service); }
private static Service AddSelfTypedService <THandler, TActivatorData>( IRegistrationBuilder <THandler, TActivatorData, SingleRegistrationStyle> rb, Type handlerType = null) { var service = new TypedService(handlerType ?? typeof(THandler)); rb.RegistrationData.AddService(service); return(service); }
public static void InjectProperties(IComponentContext context, object instance, IPropertySelector propertySelector) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (instance == null) { throw new ArgumentNullException(nameof(instance)); } if (propertySelector == null) { throw new ArgumentNullException(nameof(propertySelector)); } var instanceType = instance.GetType(); foreach (var property in instanceType .GetRuntimeProperties() .Where(pi => pi.CanWrite)) { var propertyType = property.PropertyType; if (propertyType.GetTypeInfo().IsValueType&& !propertyType.GetTypeInfo().IsEnum) { continue; } if (propertyType.IsArray && propertyType.GetElementType().GetTypeInfo().IsValueType) { continue; } if (propertyType.IsGenericEnumerableInterfaceType() && propertyType.GetTypeInfo().GenericTypeArguments[0].GetTypeInfo().IsValueType) { continue; } if (property.GetIndexParameters().Length != 0) { continue; } if (!propertySelector.InjectProperty(property, instance)) { continue; } object propertyValue; var propertyService = new TypedService(propertyType); var instanceTypeParameter = new NamedParameter(InstanceTypeNamedParameter, instanceType); if (context.TryResolveService(propertyService, new Parameter[] { instanceTypeParameter }, out propertyValue)) { property.SetValue(instance, propertyValue, null); } } }
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <ServiceRegistration> > registrationAccessor) { var objectService = new TypedService(typeof(object)); if (service == objectService) { yield return(Factory.CreateSingletonObjectRegistration(_instance)); } }
/// <summary> /// 装配字段 /// </summary> /// <param name="property"></param> /// <param name="context"></param> /// <param name="Parameters"></param> /// <param name="instance"></param> /// <param name="allowCircle"></param> /// <returns></returns> public object ResolveField(FieldInfo property, IComponentContext context, IEnumerable <Parameter> Parameters, object instance, bool allowCircle) { if (!allowCircle) { return(property == null ? null : Resolve(property.DeclaringType, property.FieldType, context, "field")); } if (context == null) { throw new ArgumentNullException(nameof(context)); } if (instance == null) { throw new ArgumentNullException(nameof(instance)); } Service propertyService = null; if (!string.IsNullOrEmpty(this.Name)) { propertyService = new KeyedService(this.Name, property.FieldType); } else { propertyService = new TypedService(property.FieldType); } if (Parameters != null && Parameters.Count() == 1) { if (!(Parameters.First() is AutowiredParmeter AutowiredParmeter)) { return(null); } if (AutowiredParmeter.AutowiredChains.TryGetValue(property.FieldType.FullName, out var objectInstance)) { return(objectInstance); } else { AutowiredParmeter.Add(property.DeclaringType.FullName, instance); if (context.TryResolveService(propertyService, new Parameter[] { AutowiredParmeter }, out var propertyValue)) { return(propertyValue); } } } else { var instanceTypeParameter = new AutowiredParmeter(); instanceTypeParameter.Add(property.DeclaringType.FullName, instance); if (context.TryResolveService(propertyService, new Parameter[] { instanceTypeParameter }, out var propertyValue)) { return(propertyValue); } } return(null); }
public IRegistrationBuilder As(Type type) { if (type == null) { throw new ArgumentNullException(nameof(type)); } Service = new TypedService(type); return(this); }
static IEnumerable <Parameter> AddDecoratedComponentParameter(Type decoratedParameterType, IComponentRegistration decoratedComponent, IEnumerable <Parameter> configuredParameters) { var ts = new TypedService(decoratedParameterType); var parameter = new ResolvedParameter( (pi, c) => pi.ParameterType == decoratedParameterType, (pi, c) => c.ResolveComponent(ts, decoratedComponent, Enumerable.Empty <Parameter>())); return(new[] { parameter }.Concat(configuredParameters)); }
/// <summary> /// Inject properties onto an instance, filtered by a property selector. /// </summary> /// <param name="context">The component context to resolve dependencies from.</param> /// <param name="instance">The instance to inject onto.</param> /// <param name="propertySelector">The property selector.</param> /// <param name="parameters">The set of parameters for the resolve that can be used to satisfy injectable properties.</param> public static void InjectProperties(IComponentContext context, object instance, IPropertySelector propertySelector, IEnumerable <Parameter> parameters) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (instance == null) { throw new ArgumentNullException(nameof(instance)); } if (propertySelector == null) { throw new ArgumentNullException(nameof(propertySelector)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } var resolveParameters = parameters as Parameter[] ?? parameters.ToArray(); var instanceType = instance.GetType(); var injectableProperties = InjectableProperties.GetOrAdd(instanceType, type => GetInjectableProperties(type).ToArray()); for (var index = 0; index < injectableProperties.Length; index++) { var property = injectableProperties[index]; if (!propertySelector.InjectProperty(property, instance)) { continue; } // SetMethod will be non-null if GetInjectableProperties included it. var setParameter = property.SetMethod !.GetParameters()[0]; var valueProvider = (Func <object?>?)null; var parameter = resolveParameters.FirstOrDefault(p => p.CanSupplyValue(setParameter, context, out valueProvider)); if (parameter != null) { var setter = PropertySetters.GetOrAdd(property, MakeFastPropertySetter); setter(instance, valueProvider !()); continue; } var propertyService = new TypedService(property.PropertyType); var instanceTypeParameter = new NamedParameter(InstanceTypeNamedParameter, instanceType); if (context.TryResolveService(propertyService, new Parameter[] { instanceTypeParameter }, out var propertyValue)) { var setter = PropertySetters.GetOrAdd(property, MakeFastPropertySetter); setter(instance, propertyValue); } } }
static void StartStartableComponents(IComponentContext componentContext) { var ts = new TypedService(typeof(IStartable)); foreach (var startable in componentContext.ComponentRegistry.RegistrationsFor(ts)) { var instance = (IStartable)componentContext.ResolveComponent(ts, startable, Enumerable.Empty <Parameter>()); instance.Start(); } }
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor) { TypedService service2 = service as TypedService; if ((((service2 == null) || !service2.ServiceType.IsClass) || (service2.ServiceType.IsSubclassOf(typeof(Delegate)) || service2.ServiceType.IsAbstract)) || (!this._predicate(service2.ServiceType) || registrationAccessor(service).Any <IComponentRegistration>())) { return(Enumerable.Empty <IComponentRegistration>()); } return(new IComponentRegistration[] { RegistrationBuilder.ForType(service2.ServiceType).CreateRegistration <object, ConcreteReflectionActivatorData, SingleRegistrationStyle>() }); }
internal object Resolve(IComponentContext context, object instance, Type classType, Type memberType, IEnumerable <Parameter> Parameters) { if ((typeof(IObjectFactory).IsAssignableFrom(memberType))) { return(context.Resolve <ObjectBeanFactory>().CreateAutowiredFactory(this, memberType, classType, instance, Parameters)); } Service propertyService = null; if (!string.IsNullOrEmpty(this.Name)) { propertyService = new KeyedService(this.Name, memberType); } else { propertyService = new TypedService(memberType); } // ReSharper disable once PossibleMultipleEnumeration if (Parameters != null && Parameters.Count() == 1) { // ReSharper disable once PossibleMultipleEnumeration if (!(Parameters.First() is AutowiredParmeter AutowiredParmeter)) { return(null); } // ReSharper disable once AssignNullToNotNullAttribute if (AutowiredParmeter.TryGet(getAutowiredParmeterKey(memberType), out var objectInstance)) { return(objectInstance); } else { // ReSharper disable once PossibleNullReferenceException AutowiredParmeter.TryAdd(getAutowiredParmeterKey(classType), instance); if (context.TryResolveService(propertyService, new Parameter[] { AutowiredParmeter }, out var propertyValue)) { return(propertyValue); } } } else { var instanceTypeParameter = new AutowiredParmeter(); // ReSharper disable once PossibleNullReferenceException instanceTypeParameter.TryAdd(getAutowiredParmeterKey(classType), instance); if (context.TryResolveService(propertyService, new Parameter[] { instanceTypeParameter }, out var propertyValue)) { return(propertyValue); } } return(null); }
public void ServiceEquality(Type dependencyType, object ownedKey, Type ownedType, bool expected) { var dependencyService = new TypedService(dependencyType); var instancePerOwnedKey = new InstancePerOwnedKey(dependencyService); var ownedService = ownedKey != null ? (IServiceWithType) new KeyedService(ownedKey, ownedType) : new TypedService(ownedType); Assert.Equal(expected, instancePerOwnedKey.Equals(ownedService)); }
private static ResolveRequestContext MockResolveRequestContext() { var service = new TypedService(typeof(string)); var activator = Mock.Of <IInstanceActivator>(act => act.LimitType == typeof(string)); var registration = Mock.Of <IComponentRegistration>(reg => reg.Activator == activator); return(Mock.Of <ResolveRequestContext>( ctx => ctx.Service == service && ctx.Registration == registration)); }
public void InjectProperties(IComponentContext context, object instance, bool overrideSetValues) { if (context == null) throw new ArgumentNullException("context"); if (instance == null) throw new ArgumentNullException("instance"); var instanceType = instance.GetType(); foreach (var property in instanceType.GetProperties( BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty)) { var propertyType = property.PropertyType; if (propertyType.IsValueType && !propertyType.IsEnum) continue; if (property.GetIndexParameters().Length != 0) continue; if (!context.IsRegistered(propertyType)) continue; var accessors = property.GetAccessors(false); if (accessors.Length == 1 && accessors[0].ReturnType != typeof(void)) continue; if (!overrideSetValues && accessors.Length == 2 && (property.GetValue(instance, null) != null)) continue; IComponentRegistration registration; var service = new TypedService(propertyType); if (!context.ComponentRegistry.TryGetRegistration(service, out registration)) throw new ComponentNotRegisteredException(service); var lookup = context.ResolveLookup(service, registration, Enumerable.Empty<Parameter>()); try { if (lookup.Preparing) lookup.SharedInstanceActivation += (s, ea) => property.SetValue(instance, s, null); else { var propertyValue = lookup.Factory(); property.SetValue(instance, propertyValue, null); } } catch (DependencyResolutionException dre) { dre.Lookups.Push(lookup); throw; } } }
/// <summary> /// Add a handler for the Activated event. /// </summary> /// <param name="handler">The event handler.</param> /// <returns>A registration builder allowing further configuration of the component.</returns> public IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> OnActivated(Action <IActivatedEventArgs <TLimit> > handler) { if (handler == null) { throw new ArgumentNullException("handler"); } var ts = new TypedService(typeof(TLimit)); RegistrationData.ActivatedHandlers.Add( (s, e) => handler(new ActivatedEventArgs <TLimit>(ts, e.Context, e.Component, e.Parameters, (TLimit)e.Instance))); return(this); }
public void SingletonsRegisteredDirectlyAreWrappedWithLifetimeDecorator() { var registry = new ScopeRestrictedRegistry(new object(), new Dictionary <string, object>()); registry.Register(ObjectRegistration); var typedService = new TypedService(typeof(object)); registry.TryGetRegistration(typedService, out IComponentRegistration registration); Assert.IsType <ComponentRegistrationLifetimeDecorator>(registration); }
public IRegistrationBuilder As <TService>() { #region Please modify the code to pass the test /* * Please support registration by type. */ Service = new TypedService(typeof(TService)); return(this); #endregion }
public void CheckServicesShouldOnlyHaveDependenciesWithLesserLifetime(AutofacRegistrations data) { var exceptions = new List <string>(); foreach (var registration in data.ComponentRegistry.Registrations) { var registrationLifetime = data.GetLifetime(registration); foreach (var ctorParameter in data.GetRegistrationConstructorParameters(registration)) { var typedService = new TypedService(ctorParameter.ParameterType); if (ContainsMicrosoftInNamespace(typedService.ServiceType)) { continue; } if (ContainsSystemInNamespace(typedService.ServiceType)) { continue; } // If the parameter is not registered with autofac, ignore if (!data.ComponentRegistry.TryGetRegistration(typedService, out var parameterRegistration)) { continue; } var parameterLifetime = data.GetLifetime(parameterRegistration); if (parameterLifetime >= registrationLifetime) { continue; } var typeName = data.GetConcreteType(registration).ToString(); var parameterType = ctorParameter.ParameterType.ToString(); var error = $"{typeName} ({registrationLifetime}) => {parameterType} ({parameterLifetime})"; exceptions.Add(error); } } if (exceptions.Any()) { throw new Exception("The following components should not depend on with greater lifetimes: " + $"{exceptions.Aggregate((a, b) => a + Environment.NewLine + b)}"); } bool ContainsMicrosoftInNamespace(Type type) => type.Assembly.FullName.StartsWith("Microsoft", StringComparison.InvariantCultureIgnoreCase); bool ContainsSystemInNamespace(Type type) => type.Assembly.FullName.StartsWith("System", StringComparison.InvariantCultureIgnoreCase); }
protected virtual void OnContainerConfigured(IComponentRegistry registry) { var service = new TypedService(typeof(ITransportMessages)); registry.RegistrationsFor(service).First().Activated += (s, e) => { var subscriber = e.Context.Resolve <ISubscribeToMessages>(); foreach (var request in this.requests) { subscriber.Subscribe(request.Key, null, request.Value.ToArray()); } }; }
public void WhenRegistrationsAreMadeTheyDoNotAffectTheReadRegistry() { var read = new ComponentRegistry(); var cow = new CopyOnWriteRegistry(read, () => new ComponentRegistry()); var registration = RegistrationBuilder.ForType <object>().CreateRegistration(); cow.Register(registration); var objectService = new TypedService(typeof(object)); Assert.True(cow.IsRegistered(objectService)); Assert.False(read.IsRegistered(objectService)); }
public void WhenAdaptersAreAppliedButNoRegistrationsCreated_AddingAdapteesAddsAdapters() { var registry = new ComponentRegistry(); registry.AddRegistrationSource(new GeneratedFactoryRegistrationSource()); var adapterService = new TypedService(typeof(Func <object>)); registry.RegistrationsFor(adapterService); registry.Register(RegistrationBuilder.ForType <object>().CreateRegistration()); var adapters = registry.RegistrationsFor(adapterService); Assert.AreEqual(1, adapters.Count()); }
/// <summary> /// Returns true if the parameter is able to provide a value to a particular site. /// </summary> /// <param name="pi">Constructor, method, or property-mutator parameter.</param> /// <param name="context">The component context in which the value is being provided.</param> /// <param name="valueProvider">If the result is true, the valueProvider parameter will /// be set to a function that will lazily retrieve the parameter value. If the result is false, /// will be set to null.</param> /// <returns>True if a value can be supplied; otherwise, false.</returns> public override bool CanSupplyValue(ParameterInfo pi, IComponentContext context, out Func<object> valueProvider) { IComponentRegistration registration; var ts = new TypedService(pi.ParameterType); if (context.ComponentRegistry.TryGetRegistration(ts, out registration)) { var lookup = context.ResolveLookup(ts, registration, Enumerable.Empty<Parameter>()); try { valueProvider = lookup.Factory; } catch (DependencyResolutionException dre) { dre.Lookups.Push(lookup); throw; } return true; } valueProvider = null; return false; }
static IEnumerable<Parameter> AddDecoratedComponentParameter(Type decoratedParameterType, IComponentRegistration decoratedComponent, IEnumerable<Parameter> configuredParameters) { var ts = new TypedService(decoratedParameterType); var parameter = new ResolvedParameter( (pi, c) => pi.ParameterType == decoratedParameterType, (pi, c) => c.ResolveComponent(ts, decoratedComponent, Enumerable.Empty<Parameter>())); return new[] { parameter }.Concat(configuredParameters); }
static void StartStartableComponents(IComponentContext componentContext) { var ts = new TypedService(typeof(IStartable)); foreach (var startable in componentContext.ComponentRegistry.RegistrationsFor(ts)) { var instance = (IStartable)componentContext.ResolveComponent(ts, startable, Enumerable.Empty<Parameter>()); instance.Start(); } }
private Func<object> GetFactory(Type type) { BuildScopeIfRequired(); Func<object> factory; if (!SimpleCache.TryGetValue(type, out factory) && !ServiceCache.TryGetValue(type, out factory)) { var serv = new TypedService(type); IComponentRegistration reg; var inContainer = CurrentScope.ComponentRegistry.TryGetRegistration(serv, out reg); RegistrationCache.TryAdd(type, inContainer); if (inContainer) { factory = CurrentScope.ResolveLookup(serv, reg, new Parameter[0]).Factory; SimpleCache.TryAdd(type, factory); } else { factory = BuildFactoryForService(type); ServiceCache.TryAdd(type, factory); } } return factory; }
public object Resolve(Type type, object[] args) { BuildScopeIfRequired(); if (args == null) { Func<object> factory; if (!SimpleCache.TryGetValue(type, out factory)) { var serv = new TypedService(type); IComponentRegistration reg; var inContainer = CurrentScope.ComponentRegistry.TryGetRegistration(serv, out reg); RegistrationCache.TryAdd(type, inContainer); if (inContainer) factory = CurrentScope.ResolveLookup(serv, reg, new Parameter[0]).Factory; else factory = () => BuildWithAspects(type)(null); SimpleCache.TryAdd(type, factory); } return factory(); } else { Func<object[], object> factory; if (!CacheWithArguments.TryGetValue(type, out factory)) { var serv = new TypedService(type); IComponentRegistration reg; var inContainer = CurrentScope.ComponentRegistry.TryGetRegistration(serv, out reg); RegistrationCache.TryAdd(type, inContainer); if (inContainer) factory = a => CurrentScope.ResolveLookup(serv, reg, a.Select(it => new TypedParameter(it.GetType(), it))).Factory(); else factory = BuildWithAspects(type); CacheWithArguments.TryAdd(type, factory); } return factory(args); } }