Esempio n. 1
0
        /// <summary>
        /// Get an instance of the given configuration by key.
        /// </summary>
        /// <typeparam name="TConfig">Type of configuration.</typeparam>
        /// <param name="key">Requested key.</param>
        /// <returns>The requested configuration.</returns>
        public TConfig GetConfigurationByKey <TConfig>(string key) where TConfig : class
        {
            IConfigFileDefinition config = this._configRepository.GetConfigFileDefinitionByName(key);

            if (config != null)
            {
                return(this._configAccessor.GetConfigValue <TConfig>(config));
            }

            return(default(TConfig));
        }
Esempio n. 2
0
        private T GetConfigValueByPath <T>(IConfigFileDefinition definition)
        {
            if (definition == null || string.IsNullOrWhiteSpace(definition.FilePath))
            {
                return(default(T));
            }

            switch (definition.Format)
            {
            case FileFormat.Json:
                return(this._serializer.DeserializeJsonFromFile <T>(definition.FilePath));

            case FileFormat.Xml:
                return(this._serializer.DeserializeXmlFromFile <T>(definition.FilePath));

            default:
                return((T)((object)this._serializer.DeserializeTextFromFile(definition.FilePath)));
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Get configuration by
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="fileConfig"></param>
        /// <returns></returns>
        public T GetConfigValue <T>(IConfigFileDefinition fileConfig) where T : class
        {
            if (fileConfig == null || string.IsNullOrWhiteSpace(fileConfig.FilePath))
            {
                return(null);
            }

            var configCollectionKey = fileConfig.FilePath.ToLower();

            if (ConfigCollection.ContainsKey(configCollectionKey))
            {
                return(ConfigCollection[configCollectionKey] as T);
            }

            T configValue = this.GetConfigValueByPath <T>(fileConfig);

            this.AddOrUpdateConfigCollection(configCollectionKey, configValue);
            return(configValue);
        }
Esempio n. 4
0
        /// <summary>
        /// Get an instance of the given configuration with attribute or name.
        /// </summary>
        /// <typeparam name="TConfig">Type of configuration.</typeparam>
        /// <returns>The requested configuration.</returns>
        public TConfig GetConfiguration <TConfig>() where TConfig : class
        {
            Type type      = typeof(TConfig);
            var  attribute = type.GetCustomAttribute <ConfigFileAttribute>();

            if (attribute != null)
            {
                IConfigFileDefinition config = this._configRepository.GetConfigFileDefinitionByAttribute(attribute);
                if (config != null)
                {
                    return(this._configAccessor.GetConfigValue <TConfig>(config));
                }
            }
            else
            {
                return(GetConfiguration <TConfig>(string.Format("{0}.config", type.Name)));
            }

            return(default(TConfig));
        }