private Manager()
 {
     ConfigurationManager = new ConfigurationManager();
     InstanceManager = new InstanceManager();
     VersionManager = new VersionManager();
     DownloadManager = new DownloadManager();
 }

        public OpenIdConnectCachingSecurityTokenProvider(string metadataEndpoint)
        {
            _metadataEndpoint = metadataEndpoint;
            _configManager = new ConfigurationManager<OpenIdConnectConfiguration>(metadataEndpoint);

            RetrieveMetadata();
        }

        private void btnCreate_Click(object sender, RoutedEventArgs e)
        {
            if (txtAppId.Text.IsNullOrEmpty())
            {
                MessageBox.Show("Application Id не может быть пустым");
                return;
            }

            using (ConfigurationManager man = new ConfigurationManager())
            {
                UserData data = new UserData();
                data.UserName = txtUserName.Text;
                data.Password = txtUserPassword.Text;
                data.Email = txtEmail.Text;

                data.AppId = long.Parse(txtAppId.Text);
                data.AccessKey = txtAccessKey.Text;
                if (man.CreateUser(data))
                    MessageBox.Show("Пользователь успешено создан", "Информация", MessageBoxButton.OK,
                         MessageBoxImage.Information);

                else
                    MessageBox.Show("Ошибка создания пользователя", "Информация", MessageBoxButton.OK,
                         MessageBoxImage.Error);
            }
            Refresh();
        }

        internal XrmUriEditor(ConfigurationManager configManager)
        {
            InitializeComponent();

            this.configManager = configManager;
            XrmUri = new XrmUri();
        }

        protected override void OnStart(string[] args)
        {
            logger.Info("Starting service...");

            try
            {
                container = new UnityContainer();
                container.RegisterInstance(container);
                ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(container));

                configuration = new ConfigurationManager(HostMetadata.PortalApp, SpecialFolder.CommonApplicationData);
                container.RegisterInstance(configuration);

                settings = configuration.GetSection<PortalSettings>(PortalSettings.SectionKey);
                container.RegisterInstance(settings);

                loginSettings = configuration.GetSection<LoginSettings>(LoginSettings.SectionKey);
                container.RegisterInstance(loginSettings);

                portalServiceSettings = configuration.GetSection<PortalServiceSettings>(PortalServiceSettings.SectionKey);
                container.RegisterInstance(portalServiceSettings);

                portal = new PortalInstance(settings, loginSettings);
                portal.Start();

                logger.Info("Service started");
            }
            catch (Exception e)
            {
                logger.Error(e);
                throw;
            }
        }

        private async Task LoadOpenIdConnectConfigurationAsync()
        {
            var discoAddress = _settings.Authority + "/.well-known/openid-configuration";

            var manager = new ConfigurationManager<OpenIdConnectConfiguration>(discoAddress);
            _config = await manager.GetConfigurationAsync();
        }

        public static int Main(string [] args)
        {
            var configurationManager = new ConfigurationManager ();
            if (!configurationManager.LoadCommandLineArgs (args))
                return 1;

            // Show the help and exit.
            if (configurationManager.Help) {
                configurationManager.PrintHelp ();
            #if DEBUG
                Console.WriteLine ("Press any key...");
                Console.ReadKey ();
            #endif
                return 0;
            }

            // Show the version and exit.
            if (configurationManager.Version) {
                Version.Show ();
                return 0;
            }

            if (!configurationManager.LoadConfigFile ())
                return 1;

            configurationManager.SetupLogger ();

            #if DEBUG
            // Log everything while debugging
            Logger.Level = LogLevel.All;
            #endif

            Logger.Write (LogLevel.Debug, Assembly.GetExecutingAssembly ().GetName ().Name);

            string configDir = configurationManager.ConfigDir;
            if (String.IsNullOrEmpty (configDir)) {
                Logger.Write (LogLevel.Error, "You MUST provide a configuration directory with the --config-dir parameter");
                return 1;
            }

            var configDirInfo = new DirectoryInfo (configDir);
            if (!configDirInfo.Exists) {
                Logger.Write (LogLevel.Error, "The configuration directory \"{0}\" does not exist!", configDir);
                return 1;
            }

            Logger.Write (LogLevel.Debug, "Configuration directory exists, loading configuration files");

            ChildrenManager.StartChildren (configDirInfo.GetFiles("*.xml"), configurationManager);

            if (!configurationManager.Stoppable)
                return 0;

            Console.WriteLine ("Hit Return to stop the server.");
            Console.ReadLine ();

            ChildrenManager.TermChildren();
            ChildrenManager.KillChildren();
            return 0;
        }

        public MainForm()
        {
            InitializeComponent();

            var container = new UnityContainer();
            container.RegisterInstance(container);
            ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(container));

            string exePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), HostMetadata.PortalServiceExe);
            serviceManager = new ServiceManager(HostMetadata.PortalServiceName, exePath);

            configuration = new ConfigurationManager(HostMetadata.PortalApp, Environment.SpecialFolder.CommonApplicationData);
            container.RegisterInstance(configuration);

            settings = configuration.GetSection<PortalSettings>(PortalSettings.SectionKey);
            container.RegisterInstance(settings);

            portalSettingsBindingSource.DataSource = settings;

            loginSettings = configuration.GetSection<LoginSettings>(LoginSettings.SectionKey);
            container.RegisterInstance(loginSettings);

            loginSettingsControl.Settings = loginSettings;

            portalServiceSettings = configuration.GetSection<PortalServiceSettings>(PortalServiceSettings.SectionKey);
            container.RegisterInstance(portalServiceSettings);

            portalServiceSettingsBindingSource.DataSource = portalServiceSettings;

            loginSettingsControl.UserRole = UserRole.Administrator;
        }

        public void AlwaysSerialize_WithUnchangedProperty_SerializesPropertyAnyway()
        {
            // Arrange
            var secondary = new Config
                {
                    Age = 12,
                    Name = "Timothy"
                };

            var primary = new Config();

            var expected = new Config
                {
                    Name = "Timothy"
                };

            var configManager = new ConfigurationManager<Config>(
                new DummyConfigurationSource<Config>(secondary),
                new DummyConfigurationSource<Config>(primary));

            configManager.AlwaysSerialize(t => t.Name);

            var actualManager = new DummyConfigurationSource<Config>(new Config());
            configManager.SaveChanges(actualManager);

            Assert.IsTrue(new ConfigComparer().Equals(
                expected, actualManager.SavedObject));
        }

        protected override void OnStart(string[] args)
        {
            logger.Info("Starting service...");

            try
            {
                container = new UnityContainer();
                container.RegisterInstance(container);
                ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(container));

                configuration = new ConfigurationManager(HostMetadata.ServerApp, SpecialFolder.CommonApplicationData);
                container.RegisterInstance(configuration);

                settings = configuration.GetSection<ServerSettings>(ServerSettings.SectionKey);
                container.RegisterInstance(settings);

                templateServiceSettings = configuration.GetSection<TemplateServiceSettings>(TemplateServiceSettings.SectionKey);
                container.RegisterInstance(templateServiceSettings);

                var culture = settings.Language.GetCulture();
                Thread.CurrentThread.CurrentCulture = culture;
                CultureInfo.DefaultThreadCurrentCulture = culture;

                server = new ServerInstance(settings);
                server.Start();

                logger.Info("Service started");
            }
            catch (Exception e)
            {
                logger.Error(e);
                throw;
            }
        }

        public void Analyze_EmptyFile_ThrowsException()
        {
            LoggingFacility.Logger = Substitute.For<ILogger>();

            ConfigurationManager cm = new ConfigurationManager();
            bool configured = cm.IsConfigured("something");
            //rest of test
        }

        public void Init()
        {
            InitCache();

            _confMan = ConfigurationManager.Instance;
            Isolate.WhenCalled(() => _confMan.AddInMemorySqLiteEnvironment<TestMapping>("Test")).CallOriginal();
            RepositoryFixture.CreateInMemorySqLiteRepository<TestMapping>("Test");
        }

 public void ClearTheFakeObject()
 {
     _fackProjObj = null;
     _fakeActiveConfiguration = null;
     _fakeConfigurationManager = null;
     _fakeCollection = null;
     _fakeVcConfiguration = null;
 }

 public void Analyze_EmptyFile_ThrowsException()
 {
    FakeTheLogger();
    
    ConfigurationManager cm = new ConfigurationManager();
    bool configured = cm.IsConfigured("something");
     //rest of test
 }

 private static void DoProjectConfigurations(
     ConfigurationManager configurationManager
     )
 {
     foreach (Configuration configuration in configurationManager)
     {
         DoProjectConfiguration(configuration);
     }
 }

        public void Test1_Test2Result_Null()
        {
            IResultConnectionString expected = new Test1_ResultConnectionString();

            var conf = new ConfigurationManager(ConfigurationManager.GetAssemblyPath(typeof(TestConfigurationManager)));
            var result = conf.ConnectionStrings.ConnectionStrings[expected.ConnectionStringName];

            Assert.IsNull(result);
        }

        public void Test1_Test2Result_Ok()
        {
            IResultConnectionString expected = new Test1_ResultConnectionString();

            var conf = new ConfigurationManager(ConfigurationManager.GetAssemblyPath(typeof(Test1_ResultAppKey)));
            var result = conf.ConnectionStrings.ConnectionStrings[expected.ConnectionStringName];

            Assert.AreEqual(expected.Result, result.ConnectionString);
        }

        public void Test1_Test1Result_Null()
        {
            IResultAppKey expected = new Test1_ResultAppKey();

            var conf = new ConfigurationManager(ConfigurationManager.GetAssemblyPath(typeof(TestConfigurationManager)));
            var result = conf.AppSettings.Settings[expected.AppSettingsKey];

            Assert.IsNull(result);
        }

        public void Test1_Test1Result_Ok()
        {
            IResultAppKey expected = new Test1_ResultAppKey();

            var conf = new ConfigurationManager(ConfigurationManager.GetAssemblyPath(typeof(Test1_ResultAppKey)));
            var result = conf.AppSettings.Settings[expected.AppSettingsKey];

            Assert.AreEqual(expected.Result, result.Value);
        }

        public void TestConfigurationDeserialization()
        {
            var config = new ConfigurationManager().LoadFile<HomeAutomationConfiguration>("HomeAutomation.Applications.Tests/Config/HomeAutomationConfiguration.json");

            Assert.IsNotNull(config);

            Assert.AreEqual(1, config.DeviceNetworks.Count);
            Assert.AreEqual(4, config.DeviceTypes.Count);
        }