private static void EnsureConfigurationSystem()
{
lock (s_initLock)
{
if (s_initState < InitState.Usable)
{
s_initState = InitState.Started;
try
{
try
{
s_configSystem = new ClientConfigurationSystem();
s_initState = InitState.Usable;
}
catch (Exception exception)
{
s_initError = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_error"), exception);
throw s_initError;
}
}
catch
{
s_initState = InitState.Completed;
throw;
}
}
}
}
private static void EnsureConfigurationSystem() {
// If a configuration system has not yet been set,
// create the DefaultConfigurationSystem for exe's.
lock (s_initLock) {
if (s_initState < InitState.Usable) {
s_initState = InitState.Started;
try {
try {
// Create the system, but let it initialize itself
// when GetConfig is called, so that it can handle its
// own re-entrancy issues during initialization.
// When initialization is complete, the DefaultConfigurationSystem
// will call CompleteConfigInit to mark initialization as
// having completed.
// Note: the ClientConfigurationSystem has a 2-stage initialization,
// and that's why s_initState isn't set to InitState.Completed yet.
s_configSystem = new ClientConfigurationSystem();
s_initState = InitState.Usable;
}
catch (Exception e) {
s_initError = new ConfigurationErrorsException(SR.GetString(SR.Config_client_config_init_error), e);
throw s_initError;
}
}
catch {
s_initState = InitState.Completed;
throw;
}
}
}
}
/* invoked from System.Web */
internal static IInternalConfigSystem ChangeConfigurationSystem(IInternalConfigSystem newSystem)
{
if (newSystem == null)
{
throw new ArgumentNullException("newSystem");
}
lock (lockobj)
{
// KLUDGE!! We need that when an assembly loaded inside an ASP.NET
// domain does OpenExeConfiguration ("") - we must return the path
// to web.config in that instance.
string t = newSystem.GetType().ToString();
if (String.Compare(t, "System.Web.Configuration.HttpConfigurationSystem", StringComparison.OrdinalIgnoreCase) == 0)
{
systemWebInUse = true;
}
else
{
systemWebInUse = false;
}
IInternalConfigSystem old = configSystem;
configSystem = newSystem;
return(old);
}
}
public virtual void SubstituteSystemConfiguration(IConfigurationFactory factory, IList<string> fileNames)
{
if (OriginalConfiguration != null)
throw new InvalidOperationException("System default configuration already substituted.");
OriginalConfiguration = SubstituteConfigurationSystem(factory, fileNames);
}
/// <summary>
/// Re-initializes the ConfigurationManager, allowing us to merge in the settings from others app.Config
/// </summary>
public static void Install()
{
FieldInfo[] fiStateValues = null;
Type tInitState = typeof(System.Configuration.ConfigurationManager).GetNestedType("InitState", BindingFlags.NonPublic);
if (null != tInitState)
{
fiStateValues = tInitState.GetFields();
}
FieldInfo fiInit = typeof(System.Configuration.ConfigurationManager).GetField("s_initState", BindingFlags.NonPublic | BindingFlags.Static);
FieldInfo fiSystem = typeof(System.Configuration.ConfigurationManager).GetField("s_configSystem", BindingFlags.NonPublic | BindingFlags.Static);
if (fiInit != null && fiSystem != null && null != fiStateValues)
{
fiInit.SetValue(null, fiStateValues[1].GetValue(null));
fiSystem.SetValue(null, null);
}
ConfigSystem confSys = new ConfigSystem();
Type configFactoryType = Type.GetType("System.Configuration.Internal.InternalConfigSettingsFactory, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true);
IInternalConfigSettingsFactory configSettingsFactory = (IInternalConfigSettingsFactory)Activator.CreateInstance(configFactoryType, true);
configSettingsFactory.SetConfigurationSystem(confSys, false);
Type clientConfigSystemType = Type.GetType("System.Configuration.ClientConfigurationSystem, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true);
clientConfigSystem = (IInternalConfigSystem)Activator.CreateInstance(clientConfigSystemType, true);
}
public void SunnyDay()
{
FileInfo resFile = TestResourceLoader.ExportResource(this, ".config", new FileInfo(Path.GetTempFileName() + ".config"));
string exePath = resFile.FullName.Substring(0, resFile.FullName.Length - ".config".Length);
Assert.IsTrue(resFile.Exists);
IInternalConfigSystem prevConfig = null;
try
{
ExeConfigurationSystem ccs = new ExeConfigurationSystem(exePath);
prevConfig = ConfigurationUtils.SetConfigurationSystem(ccs, true);
LogSetting settings = (LogSetting)ConfigurationManager.GetSection("logging");
Assert.AreEqual(typeof(TraceLoggerFactoryAdapter), settings.FactoryAdapterType);
Assert.AreEqual("from custom config!", ConfigurationManager.AppSettings["key"]);
Assert.IsNull(ConfigurationManager.GetSection("spring/context"));
}
finally
{
if (prevConfig != null)
{
ConfigurationUtils.SetConfigurationSystem(prevConfig, true);
}
resFile.Delete();
}
}
private static void EnsureConfigurationSystem()
{
lock (s_initLock)
{
if (s_initState < InitState.Usable)
{
s_initState = InitState.Started;
try
{
try
{
s_configSystem = new ClientConfigurationSystem();
s_initState = InitState.Usable;
}
catch (Exception exception)
{
s_initError = new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_client_config_init_error"), exception);
throw s_initError;
}
}
catch
{
s_initState = InitState.Completed;
throw;
}
}
}
}
private static void EnsureConfigurationSystem()
{
// If a configuration system has not yet been set,
// create the DefaultConfigurationSystem for exe's.
lock (s_initLock) {
if (s_initState < InitState.Usable)
{
s_initState = InitState.Started;
try {
try {
// Create the system, but let it initialize itself
// when GetConfig is called, so that it can handle its
// own re-entrancy issues during initialization.
// When initialization is complete, the DefaultConfigurationSystem
// will call CompleteConfigInit to mark initialization as
// having completed.
// Note: the ClientConfigurationSystem has a 2-stage initialization,
// and that's why s_initState isn't set to InitState.Completed yet.
s_configSystem = new ClientConfigurationSystem();
s_initState = InitState.Usable;
}
catch (Exception e) {
s_initError = new ConfigurationErrorsException(SR.GetString(SR.Config_client_config_init_error), e);
throw s_initError;
}
}
catch {
s_initState = InitState.Completed;
throw;
}
}
}
}
public static void Revert() {
if (_originalConfigSystem != null) {
_configSections.Clear();
// Revert ConfigurationManager to original state
_configSystemField.SetValue(null, _originalConfigSystem);
_originalConfigSystem = null;
}
}
public static void Revert() {
if (_originalConfigSystem != null) {
_configSections.Clear();
// Revert ConfigurationManager to original state
_configSystemField.SetValue(null, _originalConfigSystem);
_originalConfigSystem = null;
}
}
public virtual void SubstituteSystemConfiguration(IConfigurationFactory factory, IList <string> fileNames)
{
if (OriginalConfiguration != null)
{
throw new InvalidOperationException("System default configuration already substituted.");
}
OriginalConfiguration = SubstituteConfigurationSystem(factory, fileNames);
}
public virtual void RestoreSystemConfiguration()
{
if (OriginalConfiguration == null)
return;
var configManager = new ReflectionAccessor(typeof(ConfigurationManager));
configManager.SetField("s_configSystem", OriginalConfiguration);
OriginalConfiguration = null;
}
public MoqConfigSystem()
{
//Ensure the setup of the ConfigurationManager before.
var count = ConfigurationManager.AppSettings.Get("asdasd");
if (oldConfigSystem == null)
{
oldConfigSystem = (IInternalConfigSystem)typeof(ConfigurationManager).GetField("s_configSystem", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
}
}
public virtual void RestoreSystemConfiguration()
{
if (OriginalConfiguration == null)
{
return;
}
var configManager = new ReflectionAccessor(typeof(ConfigurationManager));
configManager.SetField("s_configSystem", OriginalConfiguration);
OriginalConfiguration = null;
}
// Called by ASP.NET to allow hierarchical configuration settings and ASP.NET specific extenstions.
internal static void SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete)
{
lock (s_initLock)
{
// It is an error if the configuration system has already been set.
if (s_initState != InitState.NotStarted)
throw new InvalidOperationException(SR.Config_system_already_set);
s_configSystem = configSystem;
s_initState = initComplete ? InitState.Completed : InitState.Usable;
}
}
public override void SubstituteSystemConfiguration(IConfigurationFactory factory, IList <string> fileNames)
{
if (OriginalConfiguration != null)
{
throw new InvalidOperationException("Web system default configuration already substituted.");
}
IInternalConfigSystem originalConfigSystem = SubstituteConfigurationSystem(factory, fileNames);
// Web Part (10 level black magic starts here)
var httpConfigurationSystem = new ReflectionAccessor(originalConfigSystem.GetType());
// Get original values.
var configSystem = httpConfigurationSystem.GetField <IConfigSystem>("s_configSystem");
var replacingSystem = new NConfigSystemReplacement(configSystem, factory, fileNames);
// Substitute to decorated instances.
httpConfigurationSystem.SetField("s_configSystem", replacingSystem);
httpConfigurationSystem.SetField("s_configRoot", replacingSystem.Root);
// Refill system cache with new decorated records.
var systemWebAss = httpConfigurationSystem.AccessedType.Assembly;
var hostingEnviroment = new ReflectionAccessor(systemWebAss.GetType("System.Web.Hosting.HostingEnvironment"));
string siteId = hostingEnviroment.GetProperty <string>("SiteID");
string configPath = "dmachine/webroot/" + siteId;
var httpRuntime = new ReflectionAccessor(systemWebAss.GetType("System.Web.HttpRuntime"));
try
{
object cacheInternal = httpRuntime.GetProperty("CacheInternal");
var rootReplacement = replacingSystem.Root as NConfigRootReplacement;
// In case of single CPU internal caching uses CacheSingle.
if (cacheInternal.GetType().Name == "CacheSingle")
{
UpdateCacheSingle(rootReplacement, cacheInternal, configPath);
}
else
{
UpdateCacheMultiple(rootReplacement, configPath, cacheInternal);
}
}
catch (NullReferenceException)
{
// There is no CacheInternal in .Net 4.7.2
}
OriginalConfiguration = originalConfigSystem;
}
public static void OverrideSection(string sectionName, ConfigurationSection section) {
_configSections[sectionName] = section;
if (_originalConfigSystem == null) {
// Ensure ConfigurationManager is initialized by reading something from config
object o = ConfigurationManager.ConnectionStrings;
// Replace config implementation with mock
_originalConfigSystem = (IInternalConfigSystem)_configSystemField.GetValue(null);
Debug.Assert(_originalConfigSystem != null);
_configSystemField.SetValue(null, _mockConfigSystem);
}
}
public static void OverrideSection(string sectionName, ConfigurationSection section) {
_configSections[sectionName] = section;
if (_originalConfigSystem == null) {
// Ensure ConfigurationManager is initialized by reading something from config
object o = ConfigurationManager.ConnectionStrings;
// Replace config implementation with mock
_originalConfigSystem = (IInternalConfigSystem)_configSystemField.GetValue(null);
Debug.Assert(_originalConfigSystem != null);
_configSystemField.SetValue(null, _mockConfigSystem);
}
}
// Called by ASP.NET to allow hierarchical configuration settings and ASP.NET specific extenstions.
internal static void SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete)
{
lock (s_initLock)
{
// It is an error if the configuration system has already been set.
if (s_initState != InitState.NotStarted)
{
throw new InvalidOperationException(SR.Config_system_already_set);
}
s_configSystem = configSystem;
s_initState = initComplete ? InitState.Completed : InitState.Usable;
}
}
public static void Revert()
{
if (_originalConfigSystem != null)
{
_configSections.Clear();
// Revert ConfigurationManager to original state
CommonUtil.SetFieldValue(typeof(ConfigurationManager), "s_configSystem", _originalConfigSystem);
ResetConfigCache();
_originalConfigSystem = null;
}
}
internal static void SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete)
{
lock (s_initLock)
{
if (s_initState != InitState.NotStarted)
{
throw new InvalidOperationException(System.Configuration.SR.GetString("Config_system_already_set"));
}
s_configSystem = configSystem;
if (initComplete)
{
s_initState = InitState.Completed;
}
else
{
s_initState = InitState.Usable;
}
}
}
public static void OverrideSection(string sectionName, ConfigurationSection section)
{
ResetConfigCache();
_configSections[sectionName] = section;
if (_originalConfigSystem == null)
{
// Ensure ConfigurationManager is initialized by reading something from config
object o = ConfigurationManager.ConnectionStrings;
// Replace config implementation with mock
_originalConfigSystem =
(IInternalConfigSystem)CommonUtil.GetFieldValue(typeof(ConfigurationManager), "s_configSystem");
Debug.Assert(_originalConfigSystem != null);
CommonUtil.SetFieldValue(typeof(ConfigurationManager), "s_configSystem", _mockConfigSystem);
}
}
/// <summary>
/// Re-initializes the ConfigurationManager, allowing us to merge in the settings from Core.Config
/// </summary>
public static void Activate()
{
FieldInfo[] fiStateValues = null;
Type tInitState = typeof(System.Configuration.ConfigurationManager).GetNestedType("InitState", BindingFlags.NonPublic);
if (tInitState != null)
{
fiStateValues = tInitState.GetFields();
}
FieldInfo fiInit = typeof(System.Configuration.ConfigurationManager).GetField("s_initState", BindingFlags.NonPublic | BindingFlags.Static);
FieldInfo fiSystem = typeof(System.Configuration.ConfigurationManager).GetField("s_configSystem", BindingFlags.NonPublic | BindingFlags.Static);
if (fiInit != null && fiSystem != null && fiStateValues != null)
{
var state = fiStateValues[1].GetValue(null);
fiInit.SetValue(null, state);
fiSystem.SetValue(null, null);
}
ConfigSystemProxy confSys = new ConfigSystemProxy();
Type configFactoryType = Type.GetType("System.Configuration.Internal.InternalConfigSettingsFactory, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true);
IInternalConfigSettingsFactory configSettingsFactory = (IInternalConfigSettingsFactory)Activator.CreateInstance(configFactoryType, true);
configSettingsFactory.SetConfigurationSystem(confSys, false);
Type clientConfigSystemType = Type.GetType("System.Configuration.ClientConfigurationSystem, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true);
_clientConfigSystem = (IInternalConfigSystem)Activator.CreateInstance(clientConfigSystemType, true);
// Fetch configHost
FieldInfo fiClientHost = clientConfigSystemType.GetField("_configHost", BindingFlags.NonPublic | BindingFlags.Instance);
_internalConfigClientHost = (IInternalConfigClientHost) fiClientHost?.GetValue(_clientConfigSystem);
FieldInfo fiConfigHost = typeof(DelegatingConfigHost).GetField("_host", BindingFlags.NonPublic | BindingFlags.Instance);
_internalConfigHost = (IInternalConfigHost)fiConfigHost?.GetValue(_internalConfigClientHost);
// Set custom configHost
var configHost = new LuxConfigHost(_internalConfigHost);
fiConfigHost.SetValue(_internalConfigClientHost, configHost);
}
public static void Install(IEnumerable<IConfigurationProvider> providers)
{
FieldInfo[] fiStateValues = null;
Type tInitState = typeof(System.Configuration.ConfigurationManager).GetNestedType("InitState", BindingFlags.NonPublic);
if (null != tInitState)
{
fiStateValues = tInitState.GetFields();
}
FieldInfo fiInit = typeof(System.Configuration.ConfigurationManager).GetField("s_initState", BindingFlags.NonPublic | BindingFlags.Static);
FieldInfo fiSystem = typeof(System.Configuration.ConfigurationManager).GetField("s_configSystem", BindingFlags.NonPublic | BindingFlags.Static);
if (fiInit != null && fiSystem != null && null != fiStateValues)
{
fiInit.SetValue(null, fiStateValues[1].GetValue(null));
fiSystem.SetValue(null, null);
}
ConfigurationSystem confSys = new ConfigurationSystem();
Type configFactoryType = Type.GetType("System.Configuration.Internal.InternalConfigSettingsFactory, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true);
IInternalConfigSettingsFactory configSettingsFactory = (IInternalConfigSettingsFactory)Activator.CreateInstance(configFactoryType, true);
configSettingsFactory.SetConfigurationSystem(confSys, false);
Type clientConfigSystemType = Type.GetType("System.Configuration.ClientConfigurationSystem, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", true);
clientConfigSystem = (IInternalConfigSystem)Activator.CreateInstance(clientConfigSystemType, true);
configProviders = providers;
if (configProviders != null)
{
foreach (var p in configProviders)
{
p.LoadConfigurations();
}
}
}
public static void SetConfigurationSystem(IInternalConfigSystem configSystem)
{
Type configurationManagerType = typeof(ConfigurationManager);
// this does the magic. calls the internal method
// which allows me to inject a provider
// why, oh why this is not public?
configurationManagerType.InvokeMember(
"s_initState",
System.Reflection.BindingFlags.SetField |
System.Reflection.BindingFlags.Static |
System.Reflection.BindingFlags.NonPublic,
null,
configurationManagerType, new object[] { 0 });
configurationManagerType.InvokeMember(
"SetConfigurationSystem",
System.Reflection.BindingFlags.InvokeMethod |
System.Reflection.BindingFlags.Static |
System.Reflection.BindingFlags.NonPublic,
null,
configurationManagerType, new object[] { configSystem, true });
}
void IInternalConfigSettingsFactory.SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete) {
ConfigurationManager.SetConfigurationSystem(configSystem, initComplete);
}
public override void SubstituteSystemConfiguration(IConfigurationFactory factory, IList <string> fileNames)
{
if (OriginalConfiguration != null)
{
throw new InvalidOperationException("Web system default configuration already substituted.");
}
IInternalConfigSystem originalConfigSystem = SubstituteConfigurationSystem(factory, fileNames);
// Web Part (10 level black magic starts here)
var httpConfigurationSystem = new ReflectionAccessor(originalConfigSystem.GetType());
// Get original values.
var configSystem = httpConfigurationSystem.GetField <IConfigSystem>("s_configSystem");
var replacingSystem = new NConfigSystemReplacement(configSystem, factory, fileNames);
// Substitute to decorated instances.
httpConfigurationSystem.SetField("s_configSystem", replacingSystem);
httpConfigurationSystem.SetField("s_configRoot", replacingSystem.Root);
// Refill system cache with new decorated records.
var systemWebAss = httpConfigurationSystem.AccessedType.Assembly;
var hostingEnviroment = new ReflectionAccessor(systemWebAss.GetType("System.Web.Hosting.HostingEnvironment"));
string siteId = hostingEnviroment.GetProperty <string>("SiteID");
string configPath = "dmachine/webroot/" + siteId;
var httpRuntime = new ReflectionAccessor(systemWebAss.GetType("System.Web.HttpRuntime"));
var internalCache = new ReflectionAccessor(httpRuntime.GetProperty("CacheInternal"));
var caches = internalCache.GetField("_caches") as IEnumerable ?? Enumerable.Empty <object>();
// Get all site specific configuration records keys for internal cache.
var rootReplacement = replacingSystem.Root as NConfigRootReplacement;
foreach (var cache in caches)
{
// Caches stored in array ala hash, so there is could be gaps.
if (cache == null)
{
continue;
}
var cacheAcessor = new ReflectionAccessor(cache);
lock (cacheAcessor.GetField("_lock"))
{
var entries = cacheAcessor.GetField("_entries") as IEnumerable ?? Enumerable.Empty <object>();
// entries is HashTable, so just iterate through
foreach (DictionaryEntry entry in entries)
{
var keyAccessor = new ReflectionAccessor(entry.Key);
// Only configuration cache entries replaced.
if (!keyAccessor.GetProperty("Key").ToString().StartsWith(configPath))
{
continue;
}
// Key and Value is the same object in the configuration cache entry.
var entryValueAccesor = new ReflectionAccessor(keyAccessor.GetField("_value"));
var runtimeConfigAccessor = new ReflectionAccessor(entryValueAccesor.GetField("_runtimeConfig"));
IInternalConfigRecord replacingRecord = rootReplacement.CreateConfigRecord(runtimeConfigAccessor.GetField <IInternalConfigRecord>("_configRecord"));
runtimeConfigAccessor.SetField("_configRecord", replacingRecord);
runtimeConfigAccessor.SetField("_runtimeConfigLKG", null);
}
}
}
OriginalConfiguration = originalConfigSystem;
}
/// <summary>
/// Set the nested configuration system to delegate calls in case we can't resolve a config section ourselves
/// </summary>
public void SetInnerConfigurationSystem(IInternalConfigSystem innerConfigSystem)
{
_next = innerConfigSystem;
}
/* invoked from System.Web */
internal static IInternalConfigSystem ChangeConfigurationSystem (IInternalConfigSystem newSystem)
{
if (newSystem == null)
throw new ArgumentNullException ("newSystem");
lock (lockobj) {
// KLUDGE!! We need that when an assembly loaded inside an ASP.NET
// domain does OpenExeConfiguration ("") - we must return the path
// to web.config in that instance.
/*
string t = newSystem.GetType ().ToString ();
if (String.Compare (t, "System.Web.Configuration.HttpConfigurationSystem", StringComparison.OrdinalIgnoreCase) == 0)
systemWebInUse = true;
else
systemWebInUse = false;
*/
IInternalConfigSystem old = configSystem;
configSystem = newSystem;
return old;
}
}
public ConfigurationProxy(IInternalConfigSystem originalConfig, string testAssemblyPath)
{
this._originalConfig = originalConfig;
this._testAssemblyPath = testAssemblyPath;
}
/// <summary>
/// Set the nested configuration system to delegate calls in case we can't resolve a config section ourselves
/// </summary>
public void SetInnerConfigurationSystem(IInternalConfigSystem innerConfigSystem)
{
_next = innerConfigSystem;
}
public ConfigurationProxy(IInternalConfigSystem originalConfig, string testAssemblyPath)
{
this._originalConfig = originalConfig;
this._testAssemblyPath = testAssemblyPath;
}
public NSystemReplacementConfiguration(IInternalConfigSystem originalConfiguration, IConfigurationRepository repository, INSectionMergerRegistry mergerRegistry, IList<string> fileNames)
: base(repository, mergerRegistry, fileNames)
{
this.originalConfiguration = originalConfiguration;
}
void IInternalConfigSettingsFactory.SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete)
{
ConfigurationManager.SetConfigurationSystem(configSystem, initComplete);
}
/// <summary>
/// Constructor used by the internal configuration manager
/// </summary>
/// <param name="baseconf">Native instance of configuration system</param>
internal ConfigWcfConfigSystem(IInternalConfigSystem baseconf)
{
_nativeConfigSystem = baseconf;
_svc = WcfClientFactory.Create<IWcfConfigurationService>(CoreConfig.Configuration.WcfUrl);
}
public NSystemReplacementConfiguration(IInternalConfigSystem originalConfiguration, IConfigurationRepository repository, INSectionMergerRegistry mergerRegistry, IList <string> fileNames) :
base(repository, mergerRegistry, fileNames)
{
this.originalConfiguration = originalConfiguration;
}
public NSystemReplacementConfiguration CreateSystemReplacementConfiguration(IInternalConfigSystem originalConfiguration, IList <string> fileNames)
{
return(new NSystemReplacementConfiguration(originalConfiguration, ConfigurationRepository, MergerRegistry, fileNames));
}
public NSystemReplacementConfiguration CreateSystemReplacementConfiguration(IInternalConfigSystem originalConfiguration, IList<string> fileNames)
{
return new NSystemReplacementConfiguration(originalConfiguration, ConfigurationRepository, MergerRegistry, fileNames);
}
public ConfigProxy(IInternalConfigSystem baseconf)
{
this._Baseconf = baseconf;
}
internal static void SetConfigurationSystem(IInternalConfigSystem configSystem, bool initComplete)
{
lock (s_initLock)
{
if (s_initState != InitState.NotStarted)
{
throw new InvalidOperationException(System.Configuration.SR.GetString("Config_system_already_set"));
}
s_configSystem = configSystem;
if (initComplete)
{
s_initState = InitState.Completed;
}
else
{
s_initState = InitState.Usable;
}
}
}
/// <summary>
/// Constructor used by the internal configuration manager
/// </summary>
/// <param name="baseconf">Native instance of configuration system</param>
internal ConfigWcfConfigSystem(IInternalConfigSystem baseconf)
{
_nativeConfigSystem = baseconf;
_svc = WcfClientFactory.Create <IWcfConfigurationService>(CoreConfig.Configuration.WcfUrl);
}
/// <param name="baseconf">IInternalConfigSystem to modify</param>
private SecureConfigManager(IInternalConfigSystem baseconf)
{
_baseconf = baseconf;
}
public ConfigurationManagerProxy(IInternalConfigSystem baseconf)
{
this.baseconf = baseconf;
}
