// // If config has been removed because initialization was not complete, // fetch a new configuration record. The record will be created and // completely initialized as RequireCompleteInit() will have been called // on the ClientConfigurationHost before we receive this event. // private void OnConfigRemoved(object sender, InternalConfigEventArgs e) { try { IInternalConfigRecord newConfigRecord = _configRoot.GetConfigRecord(_completeConfigRecord.ConfigPath); _completeConfigRecord = newConfigRecord; _completeConfigRecord.ThrowIfInitErrors(); } catch (Exception ex) { _initError = new ConfigurationErrorsException(SR.GetString(SR.Config_client_config_init_error), ex); ConfigurationManager.SetInitError(_initError); throw _initError; } }
private void OnConfigRemoved(object sender, InternalConfigEventArgs e) { try { IInternalConfigRecord configRecord = this._configRoot.GetConfigRecord(this._completeConfigRecord.ConfigPath); this._completeConfigRecord = configRecord; this._completeConfigRecord.ThrowIfInitErrors(); } catch (Exception exception) { this._initError = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_error"), exception); ConfigurationManager.SetInitError(this._initError); throw this._initError; } }
private void EnsureInit(string configKey) { bool flag = false; lock (this) { if (!this._isUserConfigInited) { if (!this._isInitInProgress) { this._isInitInProgress = true; flag = true; } else if (!this.IsSectionUsedInInit(configKey)) { Monitor.Wait(this); } } } if (flag) { try { try { string str; this._machineConfigRecord = this._configRoot.GetConfigRecord("MACHINE"); this._machineConfigRecord.ThrowIfInitErrors(); this._isMachineConfigInited = true; if (this._isAppConfigHttp) { ConfigurationManagerHelperFactory.Instance.EnsureNetConfigLoaded(); } this._configHost.RefreshConfigPaths(); if (this._configHost.HasLocalConfig) { str = "MACHINE/EXE/ROAMING_USER/LOCAL_USER"; } else if (this._configHost.HasRoamingConfig) { str = "MACHINE/EXE/ROAMING_USER"; } else { str = "MACHINE/EXE"; } this._completeConfigRecord = this._configRoot.GetConfigRecord(str); this._completeConfigRecord.ThrowIfInitErrors(); this._isUserConfigInited = true; } catch (Exception exception) { this._initError = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_error"), exception); throw this._initError; } } catch { ConfigurationManager.SetInitError(this._initError); this._isMachineConfigInited = true; this._isUserConfigInited = true; throw; } finally { lock (this) { try { ConfigurationManager.CompleteConfigInit(); this._isInitInProgress = false; } finally { Monitor.PulseAll(this); } } } } }
// Ensure that initialization has completed, while handling re-entrancy issues // for certain sections that may be used during initialization itself. private void EnsureInit(string configKey) { bool doInit = false; lock (this) { // If the user config is not initialized, then we must either: // a. Perform the initialization ourselves if no other thread is doing it, or // b. Wait for the initialization to complete if we know the section is not used during initialization itself, or // c. Ignore initialization if the section can be used during initialization. Note that GetSection() // returns null is initialization has not completed. if (!_isUserConfigInited) { if (!_isInitInProgress) { _isInitInProgress = true; doInit = true; } else { if (!IsSectionUsedInInit(configKey)) { // Wait for initialization to complete. Monitor.Wait(this); } } } } if (!doInit) { return; } try { try { // Initialize machine configuration. _machineConfigRecord = _configRoot.GetConfigRecord( ClientConfigurationHost.MachineConfigPath); _machineConfigRecord.ThrowIfInitErrors(); // Make machine configuration available to system.net sections // when application configuration is downloaded via http. _isMachineConfigInited = true; // If we add System.Net.Configuration we'll need to kick the initialization here // to prevent deadlocks in the networking classes by loading networking config // before making any networking requests. // // Any requests for sections used in initialization during the call to // EnsureConfigLoaded() will be served by _machine.config or will return null. //if (_isAppConfigHttp) //{ //} // Now load the rest of configuration var configHostPaths = (IInternalConfigHostPaths)_configHost; configHostPaths.RefreshConfigPaths(); string configPath; if (configHostPaths.HasLocalConfig) { configPath = ClientConfigurationHost.LocalUserConfigPath; } else { configPath = configHostPaths.HasRoamingConfig ? ClientConfigurationHost.RoamingUserConfigPath : ClientConfigurationHost.ExeConfigPath; } _completeConfigRecord = _configRoot.GetConfigRecord(configPath); _completeConfigRecord.ThrowIfInitErrors(); _isUserConfigInited = true; } catch (Exception e) { _initError = new ConfigurationErrorsException(SR.Config_client_config_init_error, e); throw _initError; } } catch { ConfigurationManager.SetInitError(_initError); _isMachineConfigInited = true; _isUserConfigInited = true; throw; } finally { lock (this) { try { // Notify ConfigurationSettings that initialization has fully completed, // even if unsuccessful. ConfigurationManager.CompleteConfigInit(); _isInitInProgress = false; } finally { // Wake up all threads waiting for initialization to complete. Monitor.PulseAll(this); } } } }