/// <summary>
        ///   Try to accept dependency as a constructor parameter
        /// </summary>
        /// <param name="model">Current component model</param>
        /// <param name="dependency">Dependency</param>
        /// <returns>True if success, else false</returns>
        protected bool TryAcceptAsParameter(ComponentModel model, ResolvableDependency dependency)
        {
            bool isParameter = model.Constructors.SelectMany(c => c.Dependencies).Any(f => f.DependencyKey == dependency.Name);

            if (!isParameter)
            {
                return(false);
            }

            if (!string.IsNullOrEmpty(dependency.Value))
            {
                //AddParameter(model, dependency.Name, dependency.Value);
                model.Parameters.Add(dependency.Name, dependency.Value);
            }
            else if (dependency.IsComponent)
            {
                return(false);
            }
            else if (!m_resolver.CanResolve(dependency.ConfigName))
            {
                throw new ConfigurationProcessingException("No config property with name '" + dependency.ConfigName + "' found");
            }
            else
            {
                //AddParameter(model, dependency.Name, m_resolver.GetConfig(dependency.ConfigName));
                model.Parameters.Add(dependency.Name, m_resolver.GetConfig(dependency.ConfigName));
            }

            return(true);
        }
Exemple #2
0
        /// <summary>
        ///   Create resolvable dependencies from an entity class
        /// </summary>
        /// <param name="entityType">Type of the entity class</param>
        /// <returns>Resolvable dependencies</returns>
        public static IEnumerable <ResolvableDependency> From(Type entityType)
        {
            if (entityType == null)
            {
                throw new ArgumentNullException(nameof(entityType));
            }

            return(entityType.GetProperties().Select(f => ResolvableDependency.WithConfigProperty(f.Name, f.Name.ToLowerCamelcase())));
        }
        /// <summary>
        ///   Try to accept dependency as a public property
        /// </summary>
        /// <param name="model">Current component model</param>
        /// <param name="dependency">Dependency</param>
        /// <returns>True if success, else false</returns>
        /// <exception cref="ConfigurationProcessingException">If the config property referenced is not found</exception>
        protected bool TryAcceptAsProperty(ComponentModel model, ResolvableDependency dependency)
        {
            PropertySet propKey = model.Properties.FirstOrDefault(f => f.Property.Name.Equals(dependency.Name, StringComparison.OrdinalIgnoreCase));

            if (propKey == null)
            {
                return(false);
            }

            if (propKey.Property.GetSetMethod() == null)
            {
                return(false);
            }

            ParameterModelCollection collection = new ParameterModelCollection();

            if (dependency.Value != null)
            {
                collection.Add(propKey.Property.Name, dependency.Value);
            }
            else if (dependency.IsComponent)
            {
                collection.Add(propKey.Property.Name, "${" + dependency.ConfigName + "}");
            }
            else if (!m_resolver.CanResolve(dependency.ConfigName))
            {
                throw new ConfigurationProcessingException("No config property with name '" + dependency.ConfigName + "' found");
            }
            else
            {
                //collection.Add(propKey.Property.Name, m_resolver.GetConfig(dependency.ConfigName));
                model.CustomDependencies[propKey.Property.Name] = m_resolver.GetValue(dependency.Name, propKey.Property.PropertyType);
            }

            propKey.Dependency.Init(collection);
            m_resolvableProperties.Add(propKey.Property.Name);
            return(true);
        }