private IEnumerable <Expression> FillMembersExpression( IContainerContext containerContext, MemberInformation[] injectionMembers, RegistrationContextData registrationContext, ResolutionContext resolutionContext, Expression instance) { var length = injectionMembers.Length; var expressions = new List <Expression>(); for (var i = 0; i < length; i++) { var member = injectionMembers[i]; if (!member.CanInject(containerContext.ContainerConfigurator.ContainerConfiguration, registrationContext)) { continue; } var expression = containerContext.ResolutionStrategy .BuildResolutionExpression(containerContext, resolutionContext, member.TypeInformation, registrationContext.InjectionParameters); if (expression == null) { continue; } expressions.Add(instance.Member(member.MemberInfo).AssignTo(expression)); } return(expressions); }
private IList <MemberBinding> GetMemberBindings(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext) { var length = serviceRegistration.MetaInformation.InjectionMembers.Length; var members = new List <MemberBinding>(); for (var i = 0; i < length; i++) { var info = serviceRegistration.MetaInformation.InjectionMembers[i]; if (!serviceRegistration.CanInjectMember(info)) { continue; } var expression = containerContext.ResolutionStrategy .BuildResolutionExpression(containerContext, resolutionContext, info.TypeInformation, serviceRegistration.RegistrationContext.InjectionParameters); if (expression == null) { continue; } members.Add(info.MemberInfo.AssignTo(expression)); } return(members); }
/// <inheritdoc /> public override Expression GetExpression(IContainerContext containerContext, IServiceRegistration serviceRegistration, IObjectBuilder objectBuilder, ResolutionContext resolutionContext, Type resolveType) { if (this.expression != null) { return(this.expression); } lock (this.syncObject) { if (this.expression != null) { return(this.expression); } var expr = base.GetExpression(containerContext, serviceRegistration, objectBuilder, resolutionContext, resolveType); if (expr == null) { return(null); } object instance; if (expr.NodeType == ExpressionType.New && ((NewExpression)expr).Arguments.Count == 0) { instance = Activator.CreateInstance(expr.Type); } else { instance = expr.CompileDelegate(resolutionContext)(resolutionContext.RootScope); } this.expression = instance.AsConstant(); } return(this.expression); }
private static Expression CreateLazyExpressionCall(IContainerContext containerContext, IServiceRegistration serviceRegistration, Type type, ConstructorInfo constructor, ResolutionContext resolutionContext) { var arguments = resolutionContext.ParameterExpressions != null ? new Expression[resolutionContext.ParameterExpressions.Sum(x => x.Length)] : new Expression[0]; if (resolutionContext.ParameterExpressions != null) { var index = 0; for (var i = 0; i < resolutionContext.ParameterExpressions.Length; i++) { for (var j = 0; j < resolutionContext.ParameterExpressions[i].Length; j++) { arguments[index++] = resolutionContext.ParameterExpressions[i][j].ConvertTo(typeof(object)); } } } var callExpression = DelegateCacheMethod.CallStaticMethod( containerContext.AsConstant(), serviceRegistration.AsConstant(), resolutionContext.AsConstant(), type.AsConstant(), typeof(object).InitNewArray(arguments)); return(constructor.MakeNew(callExpression.ConvertTo(type).AsLambda())); }
private Expression HandleDisposalAndGetExpression(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Type resolveType) { var expr = this.GetExpressionInternal(containerContext, serviceRegistration, resolutionContext, resolveType); if (expr == null) { return(null); } if (!this.HandlesObjectLifecycle && serviceRegistration.RegistrationContext.Finalizer != null) { expr = this.HandleFinalizer(expr, serviceRegistration, resolutionContext.CurrentScopeParameter); } if (!serviceRegistration.ShouldHandleDisposal || this.HandlesObjectLifecycle || !expr.Type.IsDisposable()) { return(this.CheckRuntimeCircularDependenciesIfNeeded(expr, containerContext, serviceRegistration, resolutionContext, resolveType)); } var method = Constants.AddDisposalMethod.MakeGenericMethod(expr.Type); return(this.CheckRuntimeCircularDependenciesIfNeeded(resolutionContext.CurrentScopeParameter.CallMethod(method, expr), containerContext, serviceRegistration, resolutionContext, resolveType)); }
private bool TryBuildResolutionConstructor( ConstructorInformation constructor, ResolutionContext resolutionContext, IContainerContext containerContext, IServiceRegistration serviceRegistration, out TypeInformation failedParameter, out Expression[] parameterExpressions, bool skipUknownResolution = false) { var paramLength = constructor.Parameters.Length; parameterExpressions = new Expression[paramLength]; failedParameter = null; for (var i = 0; i < paramLength; i++) { var parameter = constructor.Parameters[i]; parameterExpressions[i] = containerContext.ResolutionStrategy.BuildResolutionExpression(containerContext, resolutionContext, parameter, serviceRegistration.RegistrationContext.InjectionParameters, skipUknownResolution); if (parameterExpressions[i] == null) { failedParameter = parameter; return(false); } } return(true); }
private static object CreateLazyDelegate(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Type type, object[] arguments) { var expr = serviceRegistration.GetExpression(containerContext, resolutionContext, type); return(expr.AsLambda(resolutionContext.ParameterExpressions.SelectMany(x => x)) .CompileDynamicDelegate(resolutionContext)(resolutionContext.ResolutionScope).DynamicInvoke(arguments)); }
public void RegisterType(IContainerContext context, Type registeredType, string name, Type mappedTo, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers) { // Validate imput if (mappedTo == null || registeredType == mappedTo) { return; } // Set mapping policy var policy = registeredType.GetTypeInfo().IsGenericTypeDefinition&& mappedTo.GetTypeInfo().IsGenericTypeDefinition ? new GenericTypeBuildKeyMappingPolicy(mappedTo, name) : (IBuildKeyMappingPolicy) new BuildKeyMappingPolicy(mappedTo, name); context.Policies.Set(registeredType, name, typeof(IBuildKeyMappingPolicy), policy); // Require Re-Resolve if no injectors specified var members = null == injectionMembers ? new InjectionMember[0] : injectionMembers; var overrides = members.Where(m => m is InjectionConstructor || m is InjectionMethod || m is InjectionProperty).Any(); if (lifetimeManager is IRequireBuildUpPolicy || overrides) { return; } context.Policies.Set(registeredType, name, typeof(IBuildPlanPolicy), new ResolveBuildUpPolicy()); }
private ResolutionScope(IResolverSelector resolverSelector, IServiceRegistrator serviceRegistrator, IExpressionBuilder expressionBuilder, IContainerContext containerContext, IResolutionScope rootScope, IResolutionScope parent, DelegateCache delegateCache, object name = null) : this(resolverSelector, serviceRegistrator, expressionBuilder, containerContext, delegateCache, name) { this.RootScope = rootScope; this.ParentScope = parent; }
internal ResolutionScope(IResolverSelector resolverSelector, IServiceRegistrator serviceRegistrator, IExpressionBuilder expressionBuilder, IContainerContext containerContext) : this(resolverSelector, serviceRegistrator, expressionBuilder, containerContext, new DelegateCache(), null) { this.RootScope = this; }
public Expression BuildResolutionExpression(IContainerContext containerContext, ResolutionInfo resolutionInfo, TypeInformation typeInformation, InjectionParameter[] injectionParameters) { if (typeInformation.Type == Constants.ResolverType) { return(Expression.Convert(Constants.ScopeExpression, Constants.ResolverType)); } if (resolutionInfo.ParameterExpressions != null && resolutionInfo.ParameterExpressions.Any(p => p.Type == typeInformation.Type || p.Type.Implements(typeInformation.Type))) { return(resolutionInfo.ParameterExpressions.Last(p => p.Type == typeInformation.Type || p.Type.Implements(typeInformation.Type))); } var matchingParam = injectionParameters?.FirstOrDefault(param => param.Name == typeInformation.ParameterName); if (matchingParam != null) { return(Expression.Constant(matchingParam.Value)); } var exprOverride = resolutionInfo.GetExpressionOverrideOrDefault(typeInformation.Type); if (exprOverride != null) { return(exprOverride); } var registration = containerContext.RegistrationRepository.GetRegistrationOrDefault(typeInformation, true); return(registration != null?registration.GetExpression(resolutionInfo, typeInformation.Type) : this.resolverSelector.GetResolverExpression(containerContext, typeInformation, resolutionInfo)); }
internal ServiceRegistrator(IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectBuilderSelector objectBuilderSelector) { this.containerContext = containerContext; this.containerExtensionManager = containerExtensionManager; this.objectBuilderSelector = objectBuilderSelector; }
private IList <MemberBinding> GetMemberBindings( IContainerContext containerContext, MemberInformation[] injectionMembers, RegistrationContextData registrationContext, ResolutionContext resolutionContext) { var length = injectionMembers.Length; var members = new List <MemberBinding>(); for (var i = 0; i < length; i++) { var info = injectionMembers[i]; if (!info.CanInject(containerContext.ContainerConfigurator.ContainerConfiguration, registrationContext)) { continue; } var expression = containerContext.ResolutionStrategy .BuildResolutionExpression(containerContext, resolutionContext, info.TypeInformation, registrationContext.InjectionParameters); if (expression == null) { continue; } members.Add(info.MemberInfo.AssignTo(expression)); } return(members); }
private void CreateMethodExpressions( IContainerContext containerContext, MethodInformation[] injectionMethods, RegistrationContextData registrationContext, ResolutionContext resolutionContext, Expression newExpression, Expression[] buffer) { var length = injectionMethods.Length; for (var i = 0; i < length; i++) { var info = injectionMethods[i]; var paramLength = info.Parameters.Length; if (paramLength == 0) { buffer[i] = newExpression.CallMethod(info.Method); } else { var parameters = new Expression[paramLength]; for (var j = 0; j < paramLength; j++) { parameters[j] = containerContext.ResolutionStrategy .BuildResolutionExpression(containerContext, resolutionContext, info.Parameters[j], registrationContext.InjectionParameters); } buffer[i] = newExpression.CallMethod(info.Method, parameters); } } }
private Expression CreateInitExpression( IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext) { if (serviceRegistration.SelectedConstructor != null) { if (serviceRegistration.RegistrationContext.ConstructorArguments != null) { return(serviceRegistration.SelectedConstructor.Constructor .MakeNew(serviceRegistration.RegistrationContext.ConstructorArguments.Select(Expression.Constant))); } return(this.constructorSelector.CreateResolutionConstructor(containerContext, serviceRegistration, resolutionContext, serviceRegistration.SelectedConstructor) .MakeNew()); } var rule = serviceRegistration.RegistrationContext.ConstructorSelectionRule ?? containerContext.ContainerConfigurator.ContainerConfiguration.ConstructorSelectionRule; var constructors = rule(serviceRegistration.Constructors).ToArray(); return(this.constructorSelector.SelectConstructor(serviceRegistration.ImplementationType, containerContext, resolutionContext, constructors, serviceRegistration.RegistrationContext.InjectionParameters)?.MakeNew()); }
public Expression CreateFillExpression( IContainerContext containerContext, IServiceRegistration serviceRegistration, Expression instance, ResolutionContext resolutionContext, Type serviceType) { var lines = new List <Expression>(); if (instance.Type != serviceType) { instance = instance.ConvertTo(serviceType); } var variable = serviceType.AsVariable(); var assign = variable.AssignTo(instance); lines.Add(assign); if (serviceRegistration.InjectionMembers.Length > 0) { lines.AddRange(this.FillMembersExpression(containerContext, serviceRegistration.InjectionMembers, serviceRegistration.RegistrationContext, resolutionContext, variable)); } if (serviceRegistration.InjectionMethods.Length > 0 || serviceRegistration.RegistrationContext.Initializer != null || this.containerExtensionManager.HasPostBuildExtensions) { lines.AddRange(this.CreatePostWorkExpressionIfAny(containerContext, serviceRegistration, resolutionContext, serviceType, variable)); } lines.Add(variable); //block returns with the variable return(lines.AsBlock(variable)); }
protected override Expression GetExpressionInternal(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Type resolveType) { var genericType = serviceRegistration.ImplementationType.MakeGenericType(resolveType.GetGenericArguments()); var registration = this.RegisterConcreteGenericType(containerContext, serviceRegistration, resolveType, genericType); return(registration.GetExpression(containerContext, resolutionContext, resolveType)); }
public Expression GetExpression(IContainerContext containerContext, TypeInformation typeInfo, ResolutionContext resolutionContext) { var args = typeInfo.Type.GetGenericArguments(); var tupleConstructor = typeInfo.Type.GetConstructor(args); var length = args.Length; var expressions = new Expression[length]; for (var i = 0; i < length; i++) { var argumentInfo = new TypeInformation { Type = args[i] }; var expr = containerContext.ResolutionStrategy.BuildResolutionExpression(containerContext, resolutionContext, argumentInfo, null); if (expr != null) { expressions[i] = expr; } else { return(null); } } return(tupleConstructor.MakeNew(expressions)); }
public static CreateInstance CreateConstructorExpression(IContainerContext containerContext, ResolutionConstructor resolutionConstructor, ResolutionMember[] members = null) { var strategyParameter = Expression.Constant(containerContext.ResolutionStrategy, typeof(IResolutionStrategy)); var resolutionInfoParameter = Expression.Parameter(typeof(ResolutionInfo), "resolutionInfo"); var arguments = CreateExpressionFromResolutionTargets(resolutionConstructor.Parameters, strategyParameter, resolutionInfoParameter); var newExpression = Expression.New(resolutionConstructor.Constructor, arguments); if (members == null || members.Length == 0) return Expression.Lambda<CreateInstance>(newExpression, resolutionInfoParameter).Compile(); var length = members.Length; var propertyExpressions = new MemberBinding[length]; for (var i = 0; i < length; i++) { var member = members[i]; var propertyExpression = Expression.Bind(member.MemberInfo, CreateResolutionTargetExpression(member.ResolutionTarget, strategyParameter, resolutionInfoParameter)); propertyExpressions[i] = propertyExpression; } var initExpression = Expression.MemberInit(newExpression, propertyExpressions); return Expression.Lambda<CreateInstance>(initExpression, resolutionInfoParameter).Compile(); }
public static Expression CreateExpression(IContainerContext containerContext, ResolutionConstructor resolutionConstructor, ResolutionInfo resolutionInfo, Expression resolutionInfoExpression, ResolutionMember[] members = null) { var length = resolutionConstructor.Parameters.Length; var arguments = new Expression[length]; for (var i = 0; i < length; i++) { var parameter = resolutionConstructor.Parameters[i]; arguments[i] = containerContext.ResolutionStrategy.GetExpressionForResolutionTarget(parameter, resolutionInfo, resolutionInfoExpression); } var newExpression = Expression.New(resolutionConstructor.Constructor, arguments); if (members == null || members.Length == 0) return newExpression; { var propLength = members.Length; var propertyExpressions = new MemberBinding[propLength]; for (var i = 0; i < propLength; i++) { var member = members[i]; var propertyExpression = Expression.Bind(member.MemberInfo, containerContext.ResolutionStrategy.GetExpressionForResolutionTarget(member.ResolutionTarget, resolutionInfo, resolutionInfoExpression)); propertyExpressions[i] = propertyExpression; } return Expression.MemberInit(newExpression, propertyExpressions); } }
public bool CanResolve(IContainerContext containerContext, TypeInformation typeInformation, InjectionParameter[] injectionParameters) { return this.resolutionStrategy.CanResolve(containerContext, typeInformation, injectionParameters) || this.resolutionStrategy.CanResolve(containerContext.Container.ParentContainer.ContainerContext, typeInformation, injectionParameters); }
public void ReinitalizeExtensions(IContainerContext containerContext) { foreach (var extension in this.repository) { extension.Initialize(containerContext); } }
protected override Expression GetExpressionInternal(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Type resolveType) { if (this.expression != null) { return(this.expression); } lock (this.syncObject) { if (this.expression != null) { return(this.expression); } if (serviceRegistration.ShouldHandleDisposal && serviceRegistration.RegistrationContext.ExistingInstance is IDisposable disposable) { resolutionContext.RootScope.AddDisposableTracking(disposable); } if (serviceRegistration.RegistrationContext.Finalizer != null) { var finalizerExpression = base.HandleFinalizer(serviceRegistration.RegistrationContext.ExistingInstance.AsConstant(), serviceRegistration, resolutionContext.CurrentScopeParameter.Prop(Constants.RootScopeProperty)); return(this.expression = finalizerExpression.CompileDelegate(resolutionContext)(resolutionContext.ResolutionScope).AsConstant()); } return(this.expression = serviceRegistration.RegistrationContext.ExistingInstance.AsConstant()); } }
private ResolutionConstructor SelectConstructor(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, ConstructorInformation[] constructors) { var length = constructors.Length; var checkedConstructors = new Dictionary <ConstructorInfo, TypeInformation>(); for (var i = 0; i < length; i++) { var constructor = constructors[i]; var paramLength = constructor.Parameters.Length; var parameterExpressions = new Expression[paramLength]; var hasNullParameter = false; TypeInformation failedParameter = null; for (var j = 0; j < paramLength; j++) { var parameter = constructor.Parameters[j]; var expression = containerContext.ResolutionStrategy.BuildResolutionExpression(containerContext, resolutionContext, parameter, serviceRegistration.RegistrationContext.InjectionParameters); if (expression == null) { hasNullParameter = true; failedParameter = parameter; break; } parameterExpressions[j] = expression; } if (hasNullParameter) { if (!resolutionContext.NullResultAllowed) { checkedConstructors.Add(constructor.Constructor, failedParameter); } continue; } return(new ResolutionConstructor { Constructor = constructor.Constructor, Parameters = parameterExpressions }); } if (resolutionContext.NullResultAllowed) { return(null); } var stringBuilder = new StringBuilder(); foreach (var checkedConstructor in checkedConstructors) { stringBuilder.AppendLine($"Checked constructor {checkedConstructor.Key}, unresolvable parameter: ({checkedConstructor.Value.Type}){checkedConstructor.Value.ParameterName}"); } throw new ResolutionFailedException(serviceRegistration.ImplementationType, stringBuilder.ToString()); }
/// <summary> /// Clear down the test context. /// </summary> protected virtual void TidyUp() { // Ensure that we wipe down the core objects - NUnit re-uses the instance for all tests entityFactory = null; checkerFactory = null; container = null; containerContext = null; }
internal ResolutionContext BeginCrossContainerContext(IContainerContext currentContainerContext) { var clone = this.Clone(); clone.CurrentContainerContext = currentContainerContext; clone.ShouldFallBackToRequestInitiatorContext = clone.RequestInitiatorContainerContext != currentContainerContext; return(clone); }
public ResolutionScope(IResolverSelector resolverSelector, IServiceRegistrator serviceRegistrator, IExpressionBuilder expressionBuilder, IContainerContext containerContext, IResolutionScope rootScope, IResolutionScope parent, AvlTreeKeyValue <object, Func <IResolutionScope, object> >[] serviceDelegateCache, AvlTreeKeyValue <object, Func <IResolutionScope, Delegate> >[] factoryDelegates, object name = null) : this(resolverSelector, serviceRegistrator, expressionBuilder, containerContext, serviceDelegateCache, factoryDelegates, name) { this.RootScope = rootScope; this.ParentScope = parent; }
public ContainerConfiguration(IContainerContext context) { Context = context ?? throw new ArgumentNullException("context"); if (context.IsLocked()) { throw new ArgumentException("The container cannot already be locked."); } }
public static void UseDataAccess(this IAppBuilder app, IContainerContext context) { if (context == null) { throw new ArgumentNullException("context"); } app.Use(typeof(DataAccessMiddleware), context); }
public BuildUpObjectBuilder(object instance, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender) { this.instance = instance; this.instanceType = instance.GetType(); this.containerExtensionManager = containerExtensionManager; this.objectExtender = objectExtender; this.containerContext = containerContext; }
public override Expression GetExpression(IContainerContext containerContext, TypeInformation typeInfo, ResolutionContext resolutionContext) { if (typeInfo.HasDefaultValue) { return(typeInfo.DefaultValue.AsConstant(typeInfo.Type)); } return(typeInfo.Type.AsDefault()); }
public StoredProcedureNodeViewModel( IContainerContext context, CosmosStoredProcedure storedProcedure, NonLeafTreeNodeViewModel parent, ScriptCommands <CosmosStoredProcedure> commands, IMessenger messenger) : base(storedProcedure, context, parent, commands, messenger) { }
public UserDefinedFunctionNodeViewModel( CosmosUserDefinedFunction udf, IContainerContext context, NonLeafTreeNodeViewModel parent, ScriptCommands <CosmosUserDefinedFunction> commands, IMessenger messenger) : base(udf, context, parent, commands, messenger) { }
public void ExecuteOnRegistrationExtensions(IContainerContext containerContext, RegistrationInfo registrationInfo, InjectionParameter[] injectionParameters = null) { if (!this.hasRegistrationExtensions) return; using (this.readerWriterLock.AcquireReadLock()) { foreach (var extension in this.registrationExtensions) extension.OnRegistration(containerContext, registrationInfo, injectionParameters); } }
public TriggerNodeViewModel( CosmosTrigger trigger, IContainerContext context, NonLeafTreeNodeViewModel parent, ScriptCommands <CosmosTrigger> commands, IMessenger messenger) : base(trigger, context, parent, commands, messenger) { }
public MetaInfoProvider(IContainerContext containerContext, MetaInfoCache metaInfoCache) { this.containerContext = containerContext; this.metaInfoCache = metaInfoCache; this.HasInjectionMethod = this.metaInfoCache.InjectionMethods.Any(); this.HasInjectionMembers = this.metaInfoCache.InjectionMembers.Any(); this.sensitivityList = new Lazy<HashSet<Type>>(() => new HashSet<Type>(this.metaInfoCache.Constructors.SelectMany(constructor => constructor.Parameters, (constructor, parameter) => parameter.Type) .Concat(this.metaInfoCache.InjectionMethods.SelectMany(method => method.Parameters, (method, parameter) => parameter.Type)) .Concat(this.metaInfoCache.InjectionMembers.Select(members => members.TypeInformation.Type)).Distinct())); }
public static InvokeMethod CreateMethodExpression(IContainerContext containerContext, ResolutionTarget[] parameters, MethodInfo methodInfo) { var strategyParameter = Expression.Constant(containerContext.ResolutionStrategy, typeof(IResolutionStrategy)); var resolutionInfoParameter = Expression.Parameter(typeof(ResolutionInfo), "resolutionInfo"); var instanceParameter = Expression.Parameter(typeof(object), "instance"); var convertedInstance = Expression.Convert(instanceParameter, methodInfo.DeclaringType); var arguments = CreateExpressionFromResolutionTargets(parameters, strategyParameter, resolutionInfoParameter); var callExpression = Expression.Call(convertedInstance, methodInfo, arguments); return Expression.Lambda<InvokeMethod>(callExpression, resolutionInfoParameter, instanceParameter).Compile(); }
public ResolutionTarget BuildResolutionTarget(IContainerContext containerContext, TypeInformation typeInformation, InjectionParameter[] injectionParameters) { var target = this.resolutionStrategy.BuildResolutionTarget(containerContext, typeInformation, injectionParameters); if (target.Resolver == null && target.ResolutionTargetValue == null) return this.resolutionStrategy.BuildResolutionTarget( containerContext.Container.ParentContainer.ContainerContext, typeInformation, injectionParameters); else return target; }
public DefaultObjectBuilder(IContainerContext containerContext, IMetaInfoProvider metaInfoProvider, IContainerExtensionManager containerExtensionManager, string registrationName, InjectionParameter[] injectionParameters = null) { if (injectionParameters != null) this.injectionParameters = injectionParameters; this.instanceType = metaInfoProvider.TypeTo; this.containerExtensionManager = containerExtensionManager; this.registrationName = registrationName; this.metaInfoProvider = metaInfoProvider; this.containerContext = containerContext; }
public ResolutionTarget BuildResolutionTarget(IContainerContext containerContext, TypeInformation typeInformation, InjectionParameter[] injectionParameters) { Resolver resolver; this.resolverSelector.TryChooseResolver(containerContext, typeInformation, out resolver); return new ResolutionTarget { Resolver = resolver, TypeInformation = typeInformation, ResolutionTargetValue = injectionParameters?.FirstOrDefault(param => param.Name == typeInformation.MemberName)?.Value }; }
public EnumerableResolver(IContainerContext containerContext, TypeInformation typeInfo) : base(containerContext, typeInfo) { this.enumerableType = new TypeInformation { Type = typeInfo.Type.GetEnumerableType(), CustomAttributes = typeInfo.CustomAttributes, ParentType = typeInfo.ParentType, DependencyName = typeInfo.DependencyName }; containerContext.RegistrationRepository.TryGetTypedRepositoryRegistrations(this.enumerableType, out registrationCache); }
public object FillResolutionMembers(object instance, IContainerContext containerContext, ResolutionInfo resolutionInfo) { if (!this.metaInfoProvider.HasInjectionMembers) return instance; var members = this.GetResolutionMembers(); var count = members.Length; for (var i = 0; i < count; i++) { var value = containerContext.ResolutionStrategy.EvaluateResolutionTarget(members[i].ResolutionTarget, resolutionInfo); members[i].MemberSetter(instance, value); } return instance; }
public object FillResolutionMethods(object instance, IContainerContext containerContext, ResolutionInfo resolutionInfo) { if (!this.metaInfoProvider.HasInjectionMethod) return instance; { var methods = this.GetResolutionMethods(); var count = methods.Length; for (var i = 0; i < count; i++) { methods[i].MethodDelegate(resolutionInfo, instance); } } return instance; }
public bool TryChooseResolver(IContainerContext containerContext, TypeInformation typeInfo, out Resolver resolver, Func<ResolverRegistration, bool> filter = null) { using (this.readerWriterLock.AcquireReadLock()) { var resolverFactory = filter == null ? this.resolverRepository.FirstOrDefault( registration => registration.Predicate(containerContext, typeInfo)) : this.resolverRepository.Where(filter).FirstOrDefault( registration => registration.Predicate(containerContext, typeInfo)); if (resolverFactory != null) { resolver = resolverFactory.ResolverFactory(containerContext, typeInfo); return true; } resolver = null; return false; } }
public object ExecutePostBuildExtensions(object instance, Type targetType, IContainerContext containerContext, ResolutionInfo resolutionInfo, TypeInformation resolveType, InjectionParameter[] injectionParameters = null) { if (!this.hasPostBuildExtensions) return instance; using (this.readerWriterLock.AcquireReadLock()) { var result = instance; foreach (var extension in this.postbuildExtensions) result = extension.PostBuild(instance, targetType, containerContext, resolutionInfo, resolveType, injectionParameters); return result; } }
private object ResolveType(IContainerContext containerContext, ResolutionInfo resolutionInfo, TypeInformation resolveType) { var instance = this.constructorDelegate(resolutionInfo); if (!this.metaInfoProvider.HasInjectionMethod) return this.containerExtensionManager.ExecutePostBuildExtensions(instance, this.instanceType, containerContext, resolutionInfo, resolveType, this.injectionParameters); var methods = this.GetResolutionMethods(); var count = methods.Length; for (var i = 0; i < count; i++) { methods[i].MethodDelegate(resolutionInfo, instance); } return this.containerExtensionManager.ExecutePostBuildExtensions(instance, this.instanceType, containerContext, resolutionInfo, resolveType, this.injectionParameters); }
public bool CanResolve(IContainerContext containerContext, TypeInformation typeInfo) { using (this.readerWriterLock.AcquireReadLock()) return this.resolverRepository.Any(registration => registration.Predicate(containerContext, typeInfo)); }
public GenericTypeObjectBuilder(IContainerContext containerContext, IMetaInfoProvider metaInfoProvider) { this.metaInfoProvider = metaInfoProvider; this.containerContext = containerContext; }
public bool CanResolve(IContainerContext containerContext, TypeInformation typeInformation, InjectionParameter[] injectionParameters) { return this.resolverSelector.CanResolve(containerContext, typeInformation) || (injectionParameters != null && injectionParameters.Any(injectionParameter => injectionParameter.Name == typeInformation.MemberName)); }
public ContainerResolver(IContainerContext containerContext, TypeInformation typeInfo) : base(containerContext, typeInfo) { containerContext.RegistrationRepository.TryGetRegistrationWithConditions(typeInfo, out this.registrationCache); }
/// <summary> /// Constructs the <see cref="Resolver"/> /// </summary> /// <param name="containerContext">The <see cref="IContainerContext"/> of the <see cref="StashboxContainer"/></param> /// <param name="typeInfo">The type information about the resolved service.</param> protected Resolver(IContainerContext containerContext, TypeInformation typeInfo) { this.BuilderContext = containerContext; this.TypeInfo = typeInfo; }
public void ReinitalizeExtensions(IContainerContext containerContext) { using (this.readerWriterLock.AcquireReadLock()) foreach (var extension in this.postbuildExtensions.OfType<IContainerExtension>().Concat(this.registrationExtensions)) extension.Initialize(containerContext); }
public TestResolver(IContainerContext containerContext, TypeInformation typeInfo) : base(containerContext, typeInfo) { }
private FactoryObjectBuilder(IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender) { this.containerExtensionManager = containerExtensionManager; this.objectExtender = objectExtender; this.containerContext = containerContext; }
public FactoryObjectBuilder(Func<object, object, object, object> threeParamsFactory, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender) : this(containerContext, containerExtensionManager, objectExtender) { this.threeParamsFactory = threeParamsFactory; }
public FactoryObjectBuilder(Func<object> factory, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender) : this(containerContext, containerExtensionManager, objectExtender) { this.singleFactory = factory; }