C# IConfigurationSource类代码示例

 /// <summary>
 /// Initializes a new instance of the <see cref="EntLib5Factory"/> class.
 /// </summary>
 /// <param name="EntLib5ConfigurationSrc">The enterprise library 5.0 configuration source to load. Supercedes any configuration found in the Config file.</param>
 public EntLib5Factory(IConfigurationSource EntLib5ConfigurationSrc)
 {
     // replace any settings from App.Config with the ones in the provided config source
     var builder = new ConfigurationSourceBuilder();
     builder.UpdateConfigurationWithReplace(EntLib5ConfigurationSrc);
     EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(EntLib5ConfigurationSrc);
 }

        /// <summary>
        /// Builds an instance of the concrete subtype of <see cref="T:Microsoft.Practices.EnterpriseLibrary.Data.Database"/> 
        /// the receiver knows how to build, based on the provided connection string and any configuration information 
        /// that might be contained by the <paramref name="configurationSource"/>.
        /// </summary>
        /// <param name="name">The name for the new database instance.</param>
        /// <param name="connectionStringSettings">The connection string for the new database instance.</param>
        /// <param name="configurationSource">The source for any additional configuration information.</param>
        /// <returns>
        /// The new database instance.
        /// </returns>
        public Database Assemble(string name, ConnectionStringSettings connectionStringSettings,
                                 IConfigurationSource configurationSource) {
            if(IsDebugEnabled)
                log.Debug("EnterpriseLibrary용 OracleProvider 인스턴스를 빌드합니다... name=[{0}]", name);

            var settings = OracleConnectionSettings.GetSettings(configurationSource);

            if(settings != null) {
                var data = settings.OracleConnectionsData.Get(name);

                if(data != null) {
                    var packages = new IOraclePackage[data.Packages.Count];
                    var num = 0;

                    foreach(var package in data.Packages) {
                        packages[num++] = package;
                    }
                    return new OracleDatabase(connectionStringSettings.ConnectionString);
                }
            }

            if(IsDebugEnabled)
                log.Debug("OracleDatabase를 생성합니다. connectionString=[{0}]", connectionStringSettings.ConnectionString);

            return new OracleDatabase(connectionStringSettings.ConnectionString);
        }

        /// <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);
                }
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ConfigurationSource"/> class.
        /// </summary>
        /// <param name="source">The source.</param>
        public ConfigurationSource(IConfigurationSource source)
            : base(source)
        {
            if (source.Servers != null && source.Servers.Any())
            {
                this.Servers = source.Servers.Select(s => new ServerConfig(s)).ToArray();
            }

            if (source.ServerTypes != null && source.ServerTypes.Any())
            {
                this.ServerTypes = source.ServerTypes.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray();
            }

            if (source.ConnectionFilters != null && source.ConnectionFilters.Any())
            {
                this.ConnectionFilters = source.ConnectionFilters.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray();
            }

            if (source.LogFactories != null && source.LogFactories.Any())
            {
                this.LogFactories = source.LogFactories.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray();
            }

            if (source.ReceiveFilterFactories != null && source.ReceiveFilterFactories.Any())
            {
                this.ReceiveFilterFactories = source.ReceiveFilterFactories.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray();
            }

            if (source.CommandLoaders != null && source.CommandLoaders.Any())
            {
                this.CommandLoaders = source.CommandLoaders.Select(s => s.CopyPropertiesTo(new TypeProviderConfig())).ToArray();
            }
        }

        private static CachingInstrumentationProvider CreateInstrumentationProvider(string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
        {
            CachingInstrumentationProvider instrumentationProvider = new CachingInstrumentationProvider();
            new InstrumentationAttachmentStrategy().AttachInstrumentation(name, instrumentationProvider, configurationSource, reflectionCache);

            return instrumentationProvider;
        }

        /// <summary>
        /// Consume the set of <see cref="TypeRegistration"/> objects and
        /// configure the associated container.
        /// </summary>
        /// <param name="configurationSource">Configuration source to read registrations from.</param>
        /// <param name="rootProvider"><see cref="ITypeRegistrationsProvider"/> that knows how to
        /// read the <paramref name="configurationSource"/> and return all relevant type registrations.</param>
        public void RegisterAll(IConfigurationSource configurationSource, ITypeRegistrationsProvider rootProvider)
        {
            RegisterAllCore(configurationSource, rootProvider);

            this.configurationSource = configurationSource;
            configurationSource.SourceChanged += OnConfigurationSourceChanged;
        }

        public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration,
            IConfigurationSource configSource)
        {
            var settings = runDescriptor.Settings;

            var types = GetTypesScopedByTestClass(endpointConfiguration);

            var transportToUse = AcceptanceTest.GetTransportIntegrationFromEnvironmentVar();
            SetupLogging(endpointConfiguration);

            Configure.Features.Enable<Sagas>();
            Configure.ScaleOut(_ => _.UseSingleBrokerQueue());

            AddMoreConfig();

            var config = Configure.With(types)
                .DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) || IsExternalContract(t))
                .DefineEndpointName(endpointConfiguration.EndpointName)
                .CustomConfigurationSource(configSource)
                .DefineBuilder(settings.GetOrNull("Builder"));

            SetSerializer(config);

            config
                .DefineTransport(transportToUse)
                .InMemorySagaPersister()
                .UseInMemoryTimeoutPersister();

            if (transportToUse == null || transportToUse is MsmqTransportIntegration || transportToUse is SqlServerTransportIntegration || transportToUse is AzureStorageQueuesTransportIntegration)
            {
                config.InMemorySubscriptionStorage();
            }

            return config.UnicastBus();
        }

 /// <summary>
 /// Consume the set of <see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.TypeRegistration"/> objects and
 /// configure the associated container.
 /// </summary>
 /// <param name="configurationSource">Configuration source to read registrations from.</param>
 /// <param name="rootProvider"><see cref="T:Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.ITypeRegistrationsProvider"/> that knows how to
 /// read the <paramref name="configurationSource"/> and return all relevant type registrations.</param>
 public void RegisterAll(IConfigurationSource configurationSource, ITypeRegistrationsProvider rootProvider)
 {
     foreach (TypeRegistration registrationEntry in rootProvider.GetRegistrations(configurationSource))
     {
         Register(registrationEntry);
     }
 }

        public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration,
            IConfigurationSource configurationSource,
            ConfigurationReflectionCache reflectionCache)
        {
            MonitoringDatabaseTraceListenerData castedObjectConfiguration
                = (MonitoringDatabaseTraceListenerData)objectConfiguration;

            Database database =
                (Database)
                context.HeadOfChain.BuildUp(context, typeof(Database), null,
                                            castedObjectConfiguration.ConnectionStringName);
            ILogFormatter formatter
                =
                LogFormatterCustomFactory.Instance.Create(context, castedObjectConfiguration.Formatter,
                                                          configurationSource, reflectionCache);

            TraceListener createdObject
                = new MonitoringDatabaseTraceListener(
                    database,
                    formatter,
                    castedObjectConfiguration.ApplicationName,
                    castedObjectConfiguration.ConnectionStringName);

            return createdObject;
        }

 public void FromConfiguration(IConfigurationSource config)
 {
     using (var host = new NullHost(config))
     {
         _metaModelRepository = host.Resolver.Resolve(typeof(IMetaModelRepository)) as IMetaModelRepository;
     }
 }

 public static void InitializeActiveRecord(IConfigurationSource source, params Type[] types)
 {
     ActiveRecordStarter.ResetInitializationFlag();
     ActiveRecordStarter.Initialize(source);
     ActiveRecordStarter.RegisterTypes(types);
     ActiveRecordStarter.CreateSchema();
 }

        /// <summary>
        /// Creates the <see cref="TypeRegistration"/> entries to use when configuring a container for Exception Handling
        /// </summary>
        /// <returns></returns>
        public IEnumerable<TypeRegistration> GetRegistrations(IConfigurationSource configurationSource)
        {
            var registrations = new List<TypeRegistration>();

            registrations.AddRange(GetDefaultInstrumentationRegistrations(configurationSource));

            foreach (ExceptionPolicyData policyData in ExceptionPolicies)
            {
                registrations.AddRange(policyData.GetRegistration(configurationSource));

                foreach (var policyTypeData in policyData.ExceptionTypes)
                {
                    TypeRegistration policyTypeRegistration =
                        policyTypeData.GetRegistration(policyData.Name);
                    registrations.Add(policyTypeRegistration);

                    registrations.AddRange(
                        policyTypeData.ExceptionHandlers.SelectMany(ehd => ehd.GetRegistrations(policyTypeRegistration.Name)));
                }
            }

            TypeRegistration managerRegistration =
                GetManagerRegistration(ExceptionPolicies.Select(p => p.Name).ToArray());
            managerRegistration.IsPublicName = true;

            registrations.Add(managerRegistration);

            return registrations;
        }

        public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration,
            IConfigurationSource configSource)
        {
            Configure.ScaleOut(_ => _.UseSingleBrokerQueue());

            new Bootstrapper();

            //We need this hack here because by default we include all assemblies minus Plugins but for these tests we need to exclude other tests!
            for (var index = 0; index < Configure.TypesToScan.Count;)
            {
                var type = Configure.TypesToScan[index];

                if (type.Assembly != Assembly.GetExecutingAssembly())
                {
                    index++;
                    continue;
                }

                if (!(type.DeclaringType == endpointConfiguration.BuilderType.DeclaringType ||
                      type.DeclaringType == endpointConfiguration.BuilderType))
                {
                    Configure.TypesToScan.RemoveAt(index);
                }
                else
                {
                    index++;
                }
            }

            LogManager.Configuration = SetupLogging(endpointConfiguration);

            return Configure.Instance;
        }

 /// <summary>
 /// Creates the bootstrap.
 /// </summary>
 /// <param name="config">The config.</param>
 /// <returns></returns>
 public static IBootstrap CreateBootstrap(IConfigurationSource config)
 {
     if (config.Isolation == IsolationMode.AppDomain)
         return new AppDomainBootstrap(config);
     else
         return new DefaultBootstrap(config);
 }

        public string MapName(string name, IConfigurationSource configurationSource)
        {
            if (name != null)
                return name;

            return new SecurityConfigurationView(configurationSource).GetDefaultSecurityCacheProviderName();
        }