ConfigurationManager
public sealed class ConfigurationManager : IConfigurationManager, IConfiguration, IConfigurationBuilder, IConfigurationRoot, IDisposable
Represents a mutable configuration object.
using Microsoft.Extensions.Configuration.Memory;
using Microsoft.Extensions.Primitives;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
namespace Microsoft.Extensions.Configuration
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
[DebuggerDisplay("{DebuggerToString(),nq}")]
[DebuggerTypeProxy(typeof(ConfigurationManagerDebugView))]
public sealed class ConfigurationManager : IConfigurationManager, IConfiguration, IConfigurationBuilder, IConfigurationRoot, IDisposable
{
private sealed class ConfigurationManagerDebugView
{
private readonly ConfigurationManager _current;
[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
public ConfigurationSectionDebugView[] Items {
get {
return ConfigurationSectionDebugView.FromConfiguration(_current, _current).ToArray();
}
}
public ConfigurationManagerDebugView(ConfigurationManager current)
{
_current = current;
}
}
private sealed class ConfigurationSources : IList<IConfigurationSource>, ICollection<IConfigurationSource>, IEnumerable<IConfigurationSource>, IEnumerable
{
private readonly List<IConfigurationSource> _sources = new List<IConfigurationSource>();
private readonly ConfigurationManager _config;
public IConfigurationSource this[int index] {
get {
return _sources[index];
}
set {
_sources[index] = value;
_config.ReloadSources();
}
}
public int Count => _sources.Count;
public bool IsReadOnly => false;
public ConfigurationSources(ConfigurationManager config)
{
_config = config;
}
public void Add(IConfigurationSource source)
{
_sources.Add(source);
_config.AddSource(source);
}
public void Clear()
{
_sources.Clear();
_config.ReloadSources();
}
public bool Contains(IConfigurationSource source)
{
return _sources.Contains(source);
}
public void CopyTo(IConfigurationSource[] array, int arrayIndex)
{
_sources.CopyTo(array, arrayIndex);
}
public List<IConfigurationSource>.Enumerator GetEnumerator()
{
return _sources.GetEnumerator();
}
public int IndexOf(IConfigurationSource source)
{
return _sources.IndexOf(source);
}
public void Insert(int index, IConfigurationSource source)
{
_sources.Insert(index, source);
_config.ReloadSources();
}
public bool Remove(IConfigurationSource source)
{
bool result = _sources.Remove(source);
_config.ReloadSources();
return result;
}
public void RemoveAt(int index)
{
_sources.RemoveAt(index);
_config.ReloadSources();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
IEnumerator<IConfigurationSource> IEnumerable<IConfigurationSource>.GetEnumerator()
{
return GetEnumerator();
}
}
private sealed class ConfigurationBuilderProperties : IDictionary<string, object>, ICollection<KeyValuePair<string, object>>, IEnumerable<KeyValuePair<string, object>>, IEnumerable
{
private readonly Dictionary<string, object> _properties = new Dictionary<string, object>();
private readonly ConfigurationManager _config;
public object this[string key] {
get {
return _properties[key];
}
set {
_properties[key] = value;
_config.ReloadSources();
}
}
public ICollection<string> Keys => _properties.Keys;
public ICollection<object> Values => _properties.Values;
public int Count => _properties.Count;
public bool IsReadOnly => false;
public ConfigurationBuilderProperties(ConfigurationManager config)
{
_config = config;
}
public void Add(string key, object value)
{
_properties.Add(key, value);
_config.ReloadSources();
}
public void Add(KeyValuePair<string, object> item)
{
((ICollection<KeyValuePair<string, object>>)_properties).Add(item);
_config.ReloadSources();
}
public void Clear()
{
_properties.Clear();
_config.ReloadSources();
}
public bool Contains(KeyValuePair<string, object> item)
{
return _properties.Contains(item);
}
public bool ContainsKey(string key)
{
return _properties.ContainsKey(key);
}
public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
{
((ICollection<KeyValuePair<string, object>>)_properties).CopyTo(array, arrayIndex);
}
public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
{
return _properties.GetEnumerator();
}
public bool Remove(string key)
{
bool result = _properties.Remove(key);
_config.ReloadSources();
return result;
}
public bool Remove(KeyValuePair<string, object> item)
{
bool result = ((ICollection<KeyValuePair<string, object>>)_properties).Remove(item);
_config.ReloadSources();
return result;
}
public bool TryGetValue(string key, [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out object value)
{
return _properties.TryGetValue(key, out value);
}
IEnumerator IEnumerable.GetEnumerator()
{
return _properties.GetEnumerator();
}
}
private readonly ConfigurationSources _sources;
private readonly ConfigurationBuilderProperties _properties;
private readonly ReferenceCountedProviderManager _providerManager = new ReferenceCountedProviderManager();
private readonly List<IDisposable> _changeTokenRegistrations = new List<IDisposable>();
private ConfigurationReloadToken _changeToken = new ConfigurationReloadToken();
[System.Runtime.CompilerServices.Nullable(2)]
public string this[string key] {
[return: System.Runtime.CompilerServices.Nullable(2)]
get {
using (ReferenceCountedProviders referenceCountedProviders = _providerManager.GetReference())
return ConfigurationRoot.GetConfiguration(referenceCountedProviders.Providers, key);
}
[param: System.Runtime.CompilerServices.Nullable(2)]
set {
using (ReferenceCountedProviders referenceCountedProviders = _providerManager.GetReference())
ConfigurationRoot.SetConfiguration(referenceCountedProviders.Providers, key, value);
}
}
IDictionary<string, object> IConfigurationBuilder.Properties {
get {
return _properties;
}
}
public IList<IConfigurationSource> Sources => _sources;
IEnumerable<IConfigurationProvider> IConfigurationRoot.Providers {
get {
return _providerManager.NonReferenceCountedProviders;
}
}
public ConfigurationManager()
{
_sources = new ConfigurationSources(this);
_properties = new ConfigurationBuilderProperties(this);
_sources.Add(new MemoryConfigurationSource());
}
public IConfigurationSection GetSection(string key)
{
return new ConfigurationSection(this, key);
}
public IEnumerable<IConfigurationSection> GetChildren()
{
return this.GetChildrenImplementation(null);
}
public void Dispose()
{
DisposeRegistrations();
_providerManager.Dispose();
}
IConfigurationBuilder IConfigurationBuilder.Add(IConfigurationSource source)
{
System.ThrowHelper.ThrowIfNull(source, "source");
_sources.Add(source);
return this;
}
IConfigurationRoot IConfigurationBuilder.Build()
{
return this;
}
IChangeToken IConfiguration.GetReloadToken()
{
return _changeToken;
}
void IConfigurationRoot.Reload()
{
using (ReferenceCountedProviders referenceCountedProviders = _providerManager.GetReference()) {
foreach (IConfigurationProvider provider in referenceCountedProviders.Providers) {
provider.Load();
}
}
RaiseChanged();
}
internal ReferenceCountedProviders GetProvidersReference()
{
return _providerManager.GetReference();
}
private void RaiseChanged()
{
Interlocked.Exchange(ref _changeToken, new ConfigurationReloadToken()).OnReload();
}
private void AddSource(IConfigurationSource source)
{
IConfigurationProvider configurationProvider = source.Build(this);
configurationProvider.Load();
List<IDisposable> changeTokenRegistrations = _changeTokenRegistrations;
IConfigurationProvider configurationProvider2 = configurationProvider;
changeTokenRegistrations.Add(ChangeToken.OnChange(configurationProvider2.GetReloadToken, RaiseChanged));
_providerManager.AddProvider(configurationProvider);
RaiseChanged();
}
private void ReloadSources()
{
DisposeRegistrations();
_changeTokenRegistrations.Clear();
List<IConfigurationProvider> list = new List<IConfigurationProvider>();
foreach (IConfigurationSource source in _sources) {
list.Add(source.Build(this));
}
foreach (IConfigurationProvider item in list) {
item.Load();
List<IDisposable> changeTokenRegistrations = _changeTokenRegistrations;
IConfigurationProvider configurationProvider = item;
changeTokenRegistrations.Add(ChangeToken.OnChange(configurationProvider.GetReloadToken, RaiseChanged));
}
_providerManager.ReplaceProviders(list);
RaiseChanged();
}
private void DisposeRegistrations()
{
foreach (IDisposable changeTokenRegistration in _changeTokenRegistrations) {
changeTokenRegistration.Dispose();
}
}
private string DebuggerToString()
{
return $"""{ConfigurationSectionDebugView.FromConfiguration(this, this).Count}";
}
}
}