C# IConfigurationSource.GetSection方法代码示例

        protected override void Arrange()
        {
            base.Arrange();

            Source = new DictionaryConfigurationSource();

            ConfigurationSourceBuilder sourceBuilder = new ConfigurationSourceBuilder();
            sourceBuilder.ConfigureExceptionHandling()
                .GivenPolicyWithName("SomePolicy")
                    .ForExceptionType<Exception>()
                        .ReplaceWith<ApplicationException>()
                        .WrapWith<ArgumentException>()
                        .ThenThrowNewException()
                    .ForExceptionType<ArithmeticException>()
                        .LogToCategory("ArithmicExceptions")
                        .ThenDoNothing()
                .GivenPolicyWithName("Global Policy")
                    .ForExceptionType<Exception>()
                        .ReplaceWith<ApplicationException>()
                        .UsingMessage("replacement message")
                        .WrapWith<Exception>()
                        .ThenNotifyRethrow()
                    .ForExceptionType<InvalidCastException>()
                        .WrapWith<ApplicationException>()
                        .WrapWith<Exception>()
                        .UsingMessage("yes, thats a known bug")
                        .ThenThrowNewException();

            sourceBuilder.UpdateConfigurationWithReplace(Source);

            Section = (ExceptionHandlingSettings)Source.GetSection(ExceptionHandlingSettings.SectionName);
        }

        /// <summary>
        /// public for unittesting purposes.
        /// </summary>
        /// <param name="configurationSource"></param>
        /// <param name="reconfiguringEventSource"></param>
        /// <returns></returns>
        public static IEnumerable<ITypeRegistrationsProvider> CreateTypeRegistrationsProviderLocators(IConfigurationSource configurationSource, IContainerReconfiguringEventSource reconfiguringEventSource)
        {
            TypeRegistrationProvidersConfigurationSection section = configurationSource.GetSection(TypeRegistrationProvidersConfigurationSection.SectionName) as TypeRegistrationProvidersConfigurationSection;
            if (section == null)
            {
                section = new TypeRegistrationProvidersConfigurationSection();
            }

            foreach (TypeRegistrationProviderElement typeRegistrationProviderElement in section.TypeRegistrationProviders)
            {
                if (!string.IsNullOrEmpty(typeRegistrationProviderElement.SectionName) &&
                    !string.IsNullOrEmpty(typeRegistrationProviderElement.ProviderTypeName))
                {
                    throw new ConfigurationErrorsException(
                        string.Format("Type Registration Provider Settings '{0}' cannot declare both sectionName and providerType attributes",
                        typeRegistrationProviderElement.Name));
                }
                if (!string.IsNullOrEmpty(typeRegistrationProviderElement.SectionName))
                {
                    yield return new ConfigSectionLocator(typeRegistrationProviderElement.SectionName, reconfiguringEventSource);
                }
                else if (!string.IsNullOrEmpty(typeRegistrationProviderElement.ProviderTypeName))
                {
                    yield return new TypeLoadingLocator(typeRegistrationProviderElement.ProviderTypeName, reconfiguringEventSource);
                }
            }
        }

 private InstrumentationConfigurationSection GetConfigurationSection(IConfigurationSource configurationSource)
 {
     InstrumentationConfigurationSection section = (InstrumentationConfigurationSection) configurationSource.GetSection("instrumentationConfiguration");
     if (section == null)
     {
         section = new InstrumentationConfigurationSection(false, false, false);
     }
     return section;
 }

		private InstrumentationConfigurationSection GetConfiguration(IConfigurationSource configurationSource)
		{
			InstrumentationConfigurationSection configurationSection
				= (InstrumentationConfigurationSection)configurationSource.GetSection(InstrumentationConfigurationSection.SectionName);
			if (configurationSection == null) configurationSection
				= new InstrumentationConfigurationSection(false, false, false);

			return configurationSection;
		}

        /// <summary>
        /// Adds to the <paramref name="container"/> the policy definitions available in the corresponding configuration section
        /// in <paramref name="configurationSource"/>, if such a section is available.
        /// </summary>
        /// <param name="container">The container on which the injection policies must be configured.</param>
        /// <param name="configurationSource">The configuration source from where the policy injection settings must be retrieved.</param>
        public static void ConfigureContainer(IUnityContainer container, IConfigurationSource configurationSource)
        {
            Guard.ArgumentNotNull(configurationSource, "configurationSource");

            var section = configurationSource.GetSection(SectionName) as PolicyInjectionSettings;
            if (section != null)
            {
                section.ConfigureContainer(container);
            }
        }

        ///<summary>
        /// Initializes a new instance of the <see cref="OracleDatabaseData"/> class with a connection string and a configuration
        /// source.
        ///</summary>
        ///<param name="connectionStringSettings">The <see cref="ConnectionStringSettings"/> for the represented database.</param>
        ///<param name="configurationSource">The <see cref="IConfigurationSource"/> from which Oracle-specific information 
        /// should be retrieved.</param>
        public OracleDatabaseData(ConnectionStringSettings connectionStringSettings, IConfigurationSource configurationSource)
            : base(connectionStringSettings, configurationSource)
        {
            var settings = (OracleConnectionSettings)
                           configurationSource.GetSection(OracleConnectionSettings.SectionName);

            if (settings != null)
            {
                ConnectionData = settings.OracleConnectionsData.Get(connectionStringSettings.Name);
            }
        }

        public string MapName(string name, IConfigurationSource configSource)
        {
            if (string.IsNullOrEmpty(name))
            {
                TerminologyServiceSettings settings =
                    configSource.GetSection(TerminologyServiceSettings.SectionName) as TerminologyServiceSettings;

                if (settings == null)
                    throw new ApplicationException(TerminologyServiceSettings.SectionName + " configuration section not found");
                name = settings.DefaultProvider;
            }

            Check.Ensure(!string.IsNullOrEmpty(name));
            return name;
        }

 public static AdmContent GenerateAdministrativeTemplateContent(IConfigurationSource configurationSource, string applicationName, IDictionary<string, ConfigurationSectionManageabilityProvider> manageabilityProviders)
 {
     AdmContentBuilder contentBuilder = new AdmContentBuilder();
     contentBuilder.StartCategory(applicationName);
     foreach (KeyValuePair<string, ConfigurationSectionManageabilityProvider> pair in manageabilityProviders)
     {
         ConfigurationSection configurationObject = configurationSource.GetSection(pair.Key);
         if (configurationObject != null)
         {
             pair.Value.AddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, applicationName);
         }
     }
     contentBuilder.EndCategory();
     return contentBuilder.GetContent();
 }

        private IEnumerable<TypeRegistration> GetRegistrationsInternal(IConfigurationSource configurationSource,
            Func<ITypeRegistrationsProvider, IConfigurationSource, IEnumerable<TypeRegistration>> registrationsAccessor)
        {
            ITypeRegistrationsProvider provider = null;
            ConfigurationSection section = configurationSource.GetSection(Name);
            if (section != null)
            {
                provider = section as ITypeRegistrationsProvider;
            }

            if (provider != null)
            {
                return registrationsAccessor(provider, configurationSource);
            }
            return Enumerable.Empty<TypeRegistration>();
        }

        public string MapName(string name, IConfigurationSource configSource)
        {
            if (null == configSource) throw new ArgumentNullException("configSource");

            if (null != name)
            {
                return name;
            }
            
            var settings = configSource.GetSection(LoginProviderSettings.SectionName) as LoginProviderSettings;
                
            if (null == settings)
            {
                throw new ConfigurationErrorsException(string.Format("Could not load configuration section {0}", LoginProviderSettings.SectionName));
            }
                
            return settings.DefaultLoginProviderPlugin;
        }

        ///<summary>
        /// Tries to retrieve the <see cref="ValidationSettings"/> and notifies the provided <see cref="IValidationInstrumentationProvider"/>
        /// if there is a <see cref="ConfigurationErrorsException"/>.  The exception is rethrown.
        ///</summary>
        ///<param name="configurationSource"></param>
        ///<param name="instrumentationProvider"></param>
        ///<returns></returns>
        public static ValidationSettings TryGet(
            IConfigurationSource configurationSource,
            IValidationInstrumentationProvider instrumentationProvider
            )
        {
            if (configurationSource == null) throw new ArgumentNullException("configurationSource");
            if (instrumentationProvider == null) throw new ArgumentNullException("instrumentationProvider");

            try
            {
                return configurationSource.GetSection(ValidationSettings.SectionName) as ValidationSettings;
            }
            catch(ConfigurationErrorsException e)
            {
                instrumentationProvider.NotifyConfigurationFailure(e);
                throw;
            }
        }

        public object CreateObject(Microsoft.Practices.ObjectBuilder.IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
        {
            TerminologyServiceSettings settings =
                configurationSource.GetSection(TerminologyServiceSettings.SectionName) as TerminologyServiceSettings;

            Check.Assert(settings != null, "settings must not be null.");
            TerminologyServiceData data = settings.TerminologyServiceProviders.Get(name) as TerminologyServiceData;
            if (data == null)
                throw new ConfigurationErrorsException("Unable to find Terminology service provider. " + name);

            Dictionary<string, ICodeSetAccess> codeSetAccessDictionary = new Dictionary<string, ICodeSetAccess>();

            foreach (CodeSetAccessProviderData codeSetAccessProviderData in data.codeSetAccessProviders)
            {
                codeSetAccessDictionary.Add(codeSetAccessProviderData.Name,
                    (ICodeSetAccess)CodeSetAccessProviderCustomFactory.Instance.Create
                    (context, codeSetAccessProviderData, configurationSource, reflectionCache));
            }

            Dictionary<string, ITerminologyAccess> terminologyAccessDictionary = new Dictionary<string, ITerminologyAccess>();

            foreach (TerminologyAccessProviderData terminologyAccessProviderData in data.TerminologyAccessProviders)
            {
                terminologyAccessDictionary.Add(terminologyAccessProviderData.Name,
                    (ITerminologyAccess)TerminologyAccessProviderCustomFactory.Instance.Create
                    (context, terminologyAccessProviderData, configurationSource, reflectionCache));
            }

            ITerminologyService terminologyService = new TerminologyService(terminologyAccessDictionary, codeSetAccessDictionary);

            if (context.Locator != null)
            {
                ILifetimeContainer lifetime = context.Locator.Get<ILifetimeContainer>(typeof(ILifetimeContainer), SearchMode.Local);
                if (lifetime != null)
                {
                    context.Locator.Add(new DependencyResolutionLocatorKey(typeof(ITerminologyServiceProvider), name), terminologyService);
                    lifetime.Add(terminologyService);
                }
            }

            return terminologyService;
        }

        public string MapName(string name, IConfigurationSource configSource)
        {
            if (null == configSource) throw new ArgumentNullException("configSource");

            if (null != name)
            {
                return name;
            }
            else
            {
                ApplicationOnlineHandlerSettings settings = configSource.GetSection(ApplicationOnlineHandlerSettings.SectionName) as ApplicationOnlineHandlerSettings;

                if (null == settings)
                {
                    throw new ConfigurationErrorsException(string.Format("Could not load configuration section {0}", ApplicationOnlineHandlerSettings.SectionName));
                }

                return settings.DefaultApplicationOnlineHandler;
            }
        }

        public string MapName(string name, IConfigurationSource configSource)
        {
            if (null == configSource) throw new ArgumentNullException("configSource");

            if (null != name)
            {
                return name;
            }
            else
            {
                UserPermissionDefinitionProviderSettings settings = configSource.GetSection(UserPermissionDefinitionProviderSettings.SectionName) as UserPermissionDefinitionProviderSettings;

                if (null == settings)
                {
                    throw new ConfigurationErrorsException(string.Format("Could not load configuration section {0}", UserPermissionDefinitionProviderSettings.SectionName));
                }

                return settings.DefaultUserPermissionDefinitionProvider;
            }
        }

        /// <summary>
        /// Create the installer class, reading the categories from a policy set
        /// configured in the given <paramref name="configurationSource"/>.
        /// </summary>
        /// <param name="configurationSource">Configuration source containing the policy set.</param>
        public PerformanceCountersInstaller(IConfigurationSource configurationSource )
        {
            categoryNames = new List<string>();

            PolicyInjectionSettings settings =
                configurationSource.GetSection(PolicyInjectionSettings.SectionName) as PolicyInjectionSettings;

            if( settings != null )
            {
                foreach(PolicyData policyData in settings.Policies)
                {
                    foreach(CallHandlerData handlerData in policyData.Handlers)
                    {
                        PerformanceCounterCallHandlerData perfHandlerData =
                            handlerData as PerformanceCounterCallHandlerData;
                        if(perfHandlerData != null)
                        {
                            categoryNames.Add(perfHandlerData.CategoryName);
                        }
                    }
                }
            }
        }