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);
 }
        /// <summary>
        /// Gets the instance managed by the <see cref="SingletonLifetime"/>
        /// </summary>
        /// <param name="objectBuilder">An <see cref="IObjectBuilder"/> implementation.</param>
        /// <param name="resolutionInfo">The info about the actual resolution.</param>
        /// <param name="resolveType">The type info about the resolved type.</param>
        /// <returns>The lifetime managed object.</returns>
        public object GetInstance(IObjectBuilder objectBuilder, ResolutionInfo resolutionInfo, TypeInformation resolveType)
        {
            if (this.instance != null) return this.instance;
            lock (this.syncObject)
            {
                if (this.instance != null) return this.instance;
                this.instance = objectBuilder.BuildInstance(resolutionInfo, resolveType);
            }

            return this.instance;
        }
        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 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 object BuildInstance(ResolutionInfo resolutionInfo, TypeInformation resolveType)
        {
            if (this.builtInstance != null) return this.builtInstance;
            lock (this.syncObject)
            {
                if (this.builtInstance != null) return this.builtInstance;
                this.builtInstance = this.objectExtender.FillResolutionMembers(this.instance, this.containerContext, resolutionInfo);
                this.builtInstance = this.objectExtender.FillResolutionMethods(this.builtInstance, this.containerContext, resolutionInfo);
                this.builtInstance = this.containerExtensionManager.ExecutePostBuildExtensions(this.builtInstance, this.instanceType, this.containerContext, resolutionInfo, resolveType);
            }

            return this.builtInstance;
        }
        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 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 Expression GetExpression(ResolutionInfo resolutionInfo, Expression resolutionInfoExpression, TypeInformation resolveType)
        {
            IServiceRegistration registration;
            if (this.containerContext.RegistrationRepository
                .TryGetRegistrationWithConditionsWithoutGenericDefinitionExtraction(resolveType, out registration))
                return registration.GetExpression(resolutionInfo, resolutionInfoExpression, resolveType);

            lock (this.syncObject)
            {
                if (this.containerContext.RegistrationRepository
                    .TryGetRegistrationWithConditionsWithoutGenericDefinitionExtraction(resolveType, out registration))
                    return registration.GetExpression(resolutionInfo, resolutionInfoExpression, resolveType);

                var genericType = this.metaInfoProvider.TypeTo.MakeGenericType(resolveType.Type.GenericTypeArguments);
                this.containerContext.Container.RegisterType(resolveType.Type, genericType);

                this.containerContext.RegistrationRepository
                    .TryGetRegistrationWithConditionsWithoutGenericDefinitionExtraction(resolveType, out registration);

                return registration.GetExpression(resolutionInfo, resolutionInfoExpression, resolveType);
            }
        }
        public object BuildInstance(ResolutionInfo resolutionInfo, TypeInformation resolveType)
        {
            if (this.metaInfoProvider.HasInjectionMethod || this.containerExtensionManager.HasPostBuildExtensions)
            {
                if (this.constructorDelegate != null && !this.isConstructorDirty) return this.ResolveType(containerContext, resolutionInfo, resolveType);

                lock (this.syncObject)
                {
                    if (this.constructorDelegate != null && !this.isConstructorDirty) return this.ResolveType(containerContext, resolutionInfo, resolveType);

                    ResolutionConstructor constructor;
                    if (!this.metaInfoProvider.TryChooseConstructor(out constructor, resolutionInfo,
                            this.injectionParameters))
                        throw new ResolutionFailedException(this.metaInfoProvider.TypeTo.FullName);
                    this.constructorDelegate = ExpressionDelegateFactory.CreateConstructorExpression(this.containerContext, constructor, this.GetResolutionMembers());
                    this.resolutionConstructor = constructor;
                    this.isConstructorDirty = false;
                    return this.ResolveType(containerContext, resolutionInfo, resolveType);
                }

            }

            if (this.createDelegate != null && !this.isConstructorDirty) return this.createDelegate(resolutionInfo);
            this.createDelegate = this.containerContext.DelegateRepository.GetOrAdd(this.registrationName, () =>
            {
                ResolutionConstructor constructor;
                if (!this.metaInfoProvider.TryChooseConstructor(out constructor, resolutionInfo,
                    this.injectionParameters))
                    throw new ResolutionFailedException(this.metaInfoProvider.TypeTo.FullName);

                var parameter = Expression.Parameter(typeof(ResolutionInfo));
                this.createDelegate = Expression.Lambda<Func<ResolutionInfo, object>>(this.GetExpressionInternal(constructor, resolutionInfo, parameter), parameter).Compile();
                this.resolutionConstructor = constructor;
                this.isConstructorDirty = false;
                return this.createDelegate;
            }, this.isConstructorDirty);

            return this.createDelegate(resolutionInfo);
        }
        public object BuildInstance(ResolutionInfo resolutionInfo, TypeInformation resolveType)
        {
            object instance = null;

            if (this.singleFactory != null)
                instance = this.singleFactory.Invoke();

            if (this.oneParamsFactory != null)
                instance = this.oneParamsFactory.Invoke(resolutionInfo.FactoryParams.ElementAt(0));

            if (this.twoParamsFactory != null)
                instance = this.twoParamsFactory.Invoke(resolutionInfo.FactoryParams.ElementAt(0), resolutionInfo.FactoryParams.ElementAt(1));

            if (this.threeParamsFactory != null)
                instance = this.threeParamsFactory.Invoke(
                    resolutionInfo.FactoryParams.ElementAt(0),
                    resolutionInfo.FactoryParams.ElementAt(1),
                    resolutionInfo.FactoryParams.ElementAt(2));

            var builtInstance = this.objectExtender.FillResolutionMembers(instance, containerContext, resolutionInfo);
            builtInstance = this.objectExtender.FillResolutionMembers(builtInstance, containerContext, resolutionInfo);
            return this.containerExtensionManager.ExecutePostBuildExtensions(builtInstance, builtInstance?.GetType(), containerContext, resolutionInfo, resolveType);
        }
Exemple #11
0
 /// <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;
 }
        private bool TryGetByTypeKey(TypeInformation typeInfo, out IServiceRegistration registration)
        {
            ImmutableTree<IServiceRegistration> registrations;
            if (!this.TryGetRegistrationsByType(typeInfo.Type, out registrations))
            {
                registration = null;
                return false;
            }

            registration = registrations.Value;
            return true;
        }
        private bool TryGetByTypeKeyWithConditionsWithoutGenericDefinitionExtraction(TypeInformation typeInfo, out IServiceRegistration registration)
        {
            ImmutableTree<IServiceRegistration> registrations;
            if (!this.TryGetRegistrationsByTypeWithoutGenericDefinitionExtraction(typeInfo.Type, out registrations))
            {
                registration = null;
                return false;
            }

            var serviceRegistrations = registrations.Enumerate().Select(reg => reg.Value).ToArray();
            if (serviceRegistrations.Any(reg => reg.HasCondition))
                registration = serviceRegistrations.Where(reg => reg.HasCondition)
                                                   .FirstOrDefault(reg => reg.IsUsableForCurrentContext(typeInfo));
            else
                registration = serviceRegistrations.FirstOrDefault(reg => reg.IsUsableForCurrentContext(typeInfo));

            return registration != null;
        }
        /// <summary>
        /// Tries to retrieve all registrations for a type.
        /// </summary>
        /// <param name="typeInfo">The requested type information.</param>
        /// <param name="registrations">The retrieved registrations.</param>
        /// <returns>True if registrations were found, otherwise false.</returns>
        public bool TryGetTypedRepositoryRegistrations(TypeInformation typeInfo, out IServiceRegistration[] registrations)
        {
            var serviceRegistrations = this.serviceRepository.GetValueOrDefault(typeInfo.Type.GetHashCode());
            if (serviceRegistrations == null)
            {
                Type genericTypeDefinition;
                if (this.TryHandleOpenGenericType(typeInfo.Type, out genericTypeDefinition))
                {
                    serviceRegistrations = this.genericDefinitionRepository.GetValueOrDefault(genericTypeDefinition.GetHashCode());
                }
                else
                {
                    registrations = null;
                    return false;
                }
            }

            registrations = serviceRegistrations?.Enumerate().Select(reg => reg.Value).ToArray();
            return registrations != null;
        }
        private bool TryGetByNamedKeyWithoutGenericDefinitionExtraction(TypeInformation typeInfo, out IServiceRegistration registration)
        {
            ImmutableTree<IServiceRegistration> registrations;
            if (this.TryGetRegistrationsByTypeWithoutGenericDefinitionExtraction(typeInfo.Type, out registrations))
            {
                registration = registrations.GetValueOrDefault(typeInfo.DependencyName.GetHashCode());
                return registration != null;
            }

            registration = null;
            return false;
        }
 /// <summary>
 /// Tries to retrieve a registration with conditions.
 /// </summary>
 /// <param name="typeInfo">The requested type information.</param>
 /// <param name="registration">The retrieved registration.</param>
 /// <returns>True if a registration was found, otherwise false.</returns>
 public bool TryGetRegistrationWithConditions(TypeInformation typeInfo, out IServiceRegistration registration)
 {
     return typeInfo.DependencyName == null ? this.TryGetByTypeKeyWithConditions(typeInfo, out registration) : this.TryGetByNamedKey(typeInfo, out registration);
 }
 /// <summary>
 /// Tries to retrieve a non generic definition registration with conditions.
 /// </summary>
 /// <param name="typeInfo">The requested type information.</param>
 /// <param name="registration">The retrieved registration.</param>
 /// <returns>True if a registration was found, otherwise false.</returns>
 public bool TryGetRegistrationWithConditionsWithoutGenericDefinitionExtraction(TypeInformation typeInfo, out IServiceRegistration registration)
 {
     return typeInfo.DependencyName == null ? this.TryGetByTypeKeyWithConditionsWithoutGenericDefinitionExtraction(typeInfo, out registration) :
         this.TryGetByNamedKeyWithoutGenericDefinitionExtraction(typeInfo, out registration);
 }
 public bool CanResolve(IContainerContext containerContext, TypeInformation typeInfo)
 {
     using (this.readerWriterLock.AcquireReadLock())
         return this.resolverRepository.Any(registration => registration.Predicate(containerContext, typeInfo));
 }
 /// <summary>
 /// Creates an expression for creating the resolved instance.
 /// </summary>
 /// <param name="resolutionInfo">The info about the current resolution.</param>
 /// <param name="resolutionInfoExpression">The expression of the info about the current resolution.</param>
 /// <param name="resolveType">The resolve type.</param>
 /// <returns>The expression.</returns>
 public Expression GetExpression(ResolutionInfo resolutionInfo, Expression resolutionInfoExpression, TypeInformation resolveType)
 {
     return this.lifetimeManager.GetExpression(this.objectBuilder, resolutionInfo, resolutionInfoExpression, resolveType);
 }
 /// <summary>
 /// Gets the resolved instance.
 /// </summary>
 /// <param name="resolutionInfo">The info about the current resolution.</param>
 /// <param name="resolveType">The resolve type.</param>
 /// <returns>The created object.</returns>
 public object GetInstance(ResolutionInfo resolutionInfo, TypeInformation resolveType)
 {
     return this.lifetimeManager.GetInstance(this.objectBuilder, resolutionInfo, resolveType);
 }
Exemple #21
0
 /// <summary>
 /// Gets an overridden value if has any.
 /// </summary>
 /// <param name="parameter">The type information.</param>
 /// <returns>The overridden value.</returns>
 public object GetOverriddenValue(TypeInformation parameter)
 {
     return GetTypedValue(parameter.Type) ?? GetNamedValue(parameter.DependencyName);
 }
 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 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;
            }
        }
 /// <summary>
 /// Gets the expression for getting the instance managed by the <see cref="TransientLifetime"/>
 /// </summary>
 /// <param name="objectBuilder">An <see cref="IObjectBuilder"/> implementation.</param>
 /// <param name="resolutionInfo">The info about the actual resolution.</param>
 /// <param name="resolutionInfoExpression">The expression of the info about the actual resolution.</param>
 /// <param name="resolveType">The type info about the resolved type.</param>
 /// <returns>The lifetime managed object.</returns>
 public Expression GetExpression(IObjectBuilder objectBuilder, ResolutionInfo resolutionInfo, Expression resolutionInfoExpression, TypeInformation resolveType)
 {
     return objectBuilder.GetExpression(resolutionInfo, resolutionInfoExpression, resolveType);
 }
 /// <summary>
 /// Gets the instance managed by the <see cref="TransientLifetime"/>
 /// </summary>
 /// <param name="objectBuilder">An <see cref="IObjectBuilder"/> implementation.</param>
 /// <param name="resolutionInfo">The info about the actual resolution.</param>
 /// <param name="resolveType">The type info about the resolved type.</param>
 /// <returns>The lifetime managed object.</returns>
 public object GetInstance(IObjectBuilder objectBuilder, ResolutionInfo resolutionInfo, TypeInformation resolveType)
 {
     return objectBuilder.BuildInstance(resolutionInfo, resolveType);
 }
 /// <summary>
 /// Checks whether the registration can be used for a current resolution.
 /// </summary>
 /// <param name="typeInfo">The type information.</param>
 /// <returns>True if the registration can be used for the current resolution, otherwise false.</returns>
 public bool IsUsableForCurrentContext(TypeInformation typeInfo)
 {
     return (this.targetTypeCondition == null && this.resolutionCondition == null && (this.attributeConditions == null || !this.attributeConditions.Any())) ||
            (this.targetTypeCondition != null && typeInfo.ParentType != null && this.targetTypeCondition == typeInfo.ParentType) ||
            (this.attributeConditions != null && typeInfo.CustomAttributes != null &&
             this.attributeConditions.Intersect(typeInfo.CustomAttributes.Select(attribute => attribute.GetType())).Any()) ||
            (this.resolutionCondition != null && this.resolutionCondition(typeInfo));
 }
 public Expression GetExpression(ResolutionInfo resolutionInfo, Expression resolutionInfoExpression, TypeInformation resolveType)
 {
     var callExpression = Expression.Call(Expression.Constant(this), "BuildInstance", null, resolutionInfoExpression, Expression.Constant(resolveType));
     return Expression.Convert(callExpression, resolveType.Type);
 }
 /// <summary>
 /// Check a type exists with conditions.
 /// </summary>
 /// <param name="typeInfo">The type information.</param>
 /// <returns>True if the registration found, otherwise false.</returns>
 public bool ConstainsTypeKeyWithConditions(TypeInformation typeInfo)
 {
     var registrations = this.serviceRepository.GetValueOrDefault(typeInfo.Type.GetHashCode());
     if (registrations != null)
         return registrations.Value != null &&
                registrations.Enumerate()
                    .Any(registration => registration.Value.IsUsableForCurrentContext(typeInfo));
     {
         Type genericTypeDefinition;
         if (!this.TryHandleOpenGenericType(typeInfo.Type, out genericTypeDefinition)) return false;
         registrations = this.genericDefinitionRepository.GetValueOrDefault(genericTypeDefinition.GetHashCode());
         return registrations != null && registrations.Enumerate().Any(registration => registration.Value.IsUsableForCurrentContext(new TypeInformation
         {
             Type = genericTypeDefinition,
             ParentType = typeInfo.ParentType,
             DependencyName = typeInfo.DependencyName,
             CustomAttributes = typeInfo.CustomAttributes
         }));
     }
 }
 /// <summary>
 /// Checks a non generic definition type exists in the repository.
 /// </summary>
 /// <param name="typeInfo">The type information.</param>
 /// <returns>True if the registration found, otherwise false.</returns>
 public bool ConstainsTypeKeyWithConditionsWithoutGenericDefinitionExtraction(TypeInformation typeInfo)
 {
     var registrations = this.serviceRepository.GetValueOrDefault(typeInfo.Type.GetHashCode());
     if (registrations == null) return false;
     return registrations.Value != null && registrations.Enumerate().Any(registration => registration.Value.IsUsableForCurrentContext(typeInfo));
 }
Exemple #30
0
 public TestResolver(IContainerContext containerContext, TypeInformation typeInfo)
     : base(containerContext, typeInfo)
 {
 }