每日短讯：ASP.NET Core - 选项系统之源码介绍

public static class OptionsConfigurationServiceCollectionExtensions{/// 
/// Registers a configuration instance which TOptions will bind against./// 
/// The type of options being configured./// The  to add the services to./// The configuration being bound./// The  so that additional calls can be chained.[RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]public static IServiceCollection Configure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this IServiceCollection services, IConfiguration config) where TOptions : class=> services.Configure(Options.Options.DefaultName, config);/// 
/// Registers a configuration instance which TOptions will bind against./// 
/// The type of options being configured./// The  to add the services to./// The name of the options instance./// The configuration being bound./// The  so that additional calls can be chained.[RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]public static IServiceCollection Configure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this IServiceCollection services, string name, IConfiguration config) where TOptions : class=> services.Configure(name, config, _ => { });/// 
/// Registers a configuration instance which TOptions will bind against./// 
/// The type of options being configured./// The  to add the services to./// The configuration being bound./// Used to configure the ./// The  so that additional calls can be chained.[RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]public static IServiceCollection Configure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this IServiceCollection services, IConfiguration config, Action configureBinder)where TOptions : class=> services.Configure(Options.Options.DefaultName, config, configureBinder);/// 
/// Registers a configuration instance which TOptions will bind against./// 
/// The type of options being configured./// The  to add the services to./// The name of the options instance./// The configuration being bound./// Used to configure the ./// The  so that additional calls can be chained.[RequiresUnreferencedCode(OptionsBuilderConfigurationExtensions.TrimmingRequiredUnreferencedCodeMessage)]public static IServiceCollection Configure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TOptions>(this IServiceCollection services, string name, IConfiguration config, Action configureBinder)where TOptions : class{if (services == null){throw new ArgumentNullException(nameof(services));}if (config == null){throw new ArgumentNullException(nameof(config));}services.AddOptions();services.AddSingleton>(new ConfigurationChangeTokenSource(name, config));return services.AddSingleton>(new NamedConfigureFromConfigurationOptions(name, config, configureBinder));}}

public static class OptionsServiceCollectionExtensions{public static IServiceCollection Configure(this IServiceCollection services, Action configureOptions) where TOptions : class=> services.Configure(Options.Options.DefaultName, configureOptions);public static IServiceCollection Configure(this IServiceCollection services, string name, Action configureOptions)where TOptions : class{if (services == null){throw new ArgumentNullException(nameof(services));}if (configureOptions == null){throw new ArgumentNullException(nameof(configureOptions));}services.AddOptions();services.AddSingleton>(new ConfigureNamedOptions(name, configureOptions));return services;}}

public class ConfigureOptions : IConfigureOptions where TOptions : class{/// 
/// Constructor./// 
/// The action to register.public ConfigureOptions(Action action){Action = action;}/// 
/// The configuration action./// 
public Action Action { get; }/// 
/// Invokes the registered configure ./// 
/// The options instance to configure.public virtual void Configure(TOptions options){if (options == null){throw new ArgumentNullException(nameof(options));}Action?.Invoke(options);}}

services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptions<>), typeof(UnnamedOptionsManager<>)));services.TryAdd(ServiceDescriptor.Scoped(typeof(IOptionsSnapshot<>), typeof(OptionsManager<>)));services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitor<>), typeof(OptionsMonitor<>)));services.TryAdd(ServiceDescriptor.Transient(typeof(IOptionsFactory<>), typeof(OptionsFactory<>)));services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitorCache<>), typeof(OptionsCache<>)));return services;}public static OptionsBuilder AddOptions(this IServiceCollection services, string name)where TOptions : class{if (services == null){throw new ArgumentNullException(nameof(services));}services.AddOptions();return new OptionsBuilder(services, name);}

}

public class ValidateOptions : IValidateOptions where TOptions : class{/// 
/// Constructor./// 
/// Options name./// Validation function./// Validation failure message.public ValidateOptions(string name, Func validation, string failureMessage){Name = name;Validation = validation;FailureMessage = failureMessage;}/// 
/// The options name./// 
public string Name { get; }/// 
/// The validation function./// 
public Func Validation { get; }/// 
/// The error to return when validation fails./// 
public string FailureMessage { get; }/// 
/// Validates a specific named options instance (or all when  is null)./// 
/// The name of the options instance being validated./// The options instance./// The  result.public ValidateOptionsResult Validate(string name, TOptions options){// null name is used to configure all named optionsif (Name == null || name == Name){if ((Validation?.Invoke(options)).Value){return ValidateOptionsResult.Success;}return ValidateOptionsResult.Fail(FailureMessage);}// ignored if not validating this instancereturn ValidateOptionsResult.Skip;}}

internal sealed class UnnamedOptionsManager<[DynamicallyAccessedMembers(Options.DynamicallyAccessedMembers)] TOptions> :IOptionswhere TOptions : class{private readonly IOptionsFactory _factory;private volatile object _syncObj;private volatile TOptions _value;public UnnamedOptionsManager(IOptionsFactory factory) => _factory = factory;public TOptions Value{get{if (_value is TOptions value){return value;}lock (_syncObj ?? Interlocked.CompareExchange(ref _syncObj, new object(), null) ?? _syncObj){return _value ??= _factory.Create(Options.DefaultName);}}}}

public class OptionsManager<[DynamicallyAccessedMembers(Options.DynamicallyAccessedMembers)] TOptions> :IOptions,IOptionsSnapshotwhere TOptions : class{private readonly IOptionsFactory _factory;private readonly OptionsCache _cache = new OptionsCache(); // Note: this is a private cache/// 
/// Initializes a new instance with the specified options configurations./// 
/// The factory to use to create options.public OptionsManager(IOptionsFactory factory){_factory = factory;}/// 
/// The default configured  instance, equivalent to Get(Options.DefaultName)./// 
public TOptions Value => Get(Options.DefaultName);/// 
/// Returns a configured  instance with the given ./// 
public virtual TOptions Get(string name){name = name ?? Options.DefaultName;if (!_cache.TryGetValue(name, out TOptions options)){// Store the options in our instance cache. Avoid closure on fast path by storing state into scoped locals.IOptionsFactory localFactory = _factory;string localName = name;options = _cache.GetOrAdd(name, () => localFactory.Create(localName));}return options;}}

public class OptionsMonitor<[DynamicallyAccessedMembers(Options.DynamicallyAccessedMembers)] TOptions> :IOptionsMonitor,IDisposablewhere TOptions : class{private readonly IOptionsMonitorCache _cache;private readonly IOptionsFactory _factory;private readonly List _registrations = new List();internal event Action _onChange;/// 
/// Constructor./// 
/// The factory to use to create options./// The sources used to listen for changes to the options instance./// The cache used to store options.public OptionsMonitor(IOptionsFactory factory, IEnumerable> sources, IOptionsMonitorCache cache){_factory = factory;_cache = cache;void RegisterSource(IOptionsChangeTokenSource source){IDisposable registration = ChangeToken.OnChange(  () => source.GetChangeToken(),  (name) => InvokeChanged(name),  source.Name);_registrations.Add(registration);}// The default DI container uses arrays under the covers. Take advantage of this knowledge// by checking for an array and enumerate over that, so we don"t need to allocate an enumerator.if (sources is IOptionsChangeTokenSource[] sourcesArray){foreach (IOptionsChangeTokenSource source in sourcesArray){RegisterSource(source);}}else{foreach (IOptionsChangeTokenSource source in sources){RegisterSource(source);}}}private void InvokeChanged(string name){name = name ?? Options.DefaultName;_cache.TryRemove(name);TOptions options = Get(name);if (_onChange != null){_onChange.Invoke(options, name);}}/// 
/// The present value of the options./// 
public TOptions CurrentValue{get => Get(Options.DefaultName);}/// 
/// Returns a configured  instance with the given ./// 
public virtual TOptions Get(string name){name = name ?? Options.DefaultName;return _cache.GetOrAdd(name, () => _factory.Create(name));}/// 
/// Registers a listener to be called whenever  changes./// 
/// The action to be invoked when  has changed./// An  which should be disposed to stop listening for changes.public IDisposable OnChange(Action listener){var disposable = new ChangeTrackerDisposable(this, listener);_onChange += disposable.OnChange;return disposable;}/// 
/// Removes all change registration subscriptions./// 
public void Dispose(){// Remove all subscriptions to the change tokensforeach (IDisposable registration in _registrations){registration.Dispose();}_registrations.Clear();}internal sealed class ChangeTrackerDisposable : IDisposable{private readonly Action _listener;private readonly OptionsMonitor _monitor;public ChangeTrackerDisposable(OptionsMonitor monitor, Action listener){_listener = listener;_monitor = monitor;}public void OnChange(TOptions options, string name) => _listener.Invoke(options, name);public void Dispose() => _monitor._onChange -= OnChange;}}

public class OptionsFactory<[DynamicallyAccessedMembers(Options.DynamicallyAccessedMembers)] TOptions> :IOptionsFactorywhere TOptions : class{private readonly IConfigureOptions[] _setups;private readonly IPostConfigureOptions[] _postConfigures;private readonly IValidateOptions[] _validations;/// 
/// Initializes a new instance with the specified options configurations./// 
/// The configuration actions to run./// The initialization actions to run.public OptionsFactory(IEnumerable> setups, IEnumerable> postConfigures) : this(setups, postConfigures, validations: Array.Empty>()){ }/// 
/// Initializes a new instance with the specified options configurations./// 
/// The configuration actions to run./// The initialization actions to run./// The validations to run.public OptionsFactory(IEnumerable> setups, IEnumerable> postConfigures, IEnumerable> validations){// The default DI container uses arrays under the covers. Take advantage of this knowledge// by checking for an array and enumerate over that, so we don"t need to allocate an enumerator.// When it isn"t already an array, convert it to one, but don"t use System.Linq to avoid pulling Linq in to// small trimmed applications._setups = setups as IConfigureOptions[] ?? new List>(setups).ToArray();_postConfigures = postConfigures as IPostConfigureOptions[] ?? new List>(postConfigures).ToArray();_validations = validations as IValidateOptions[] ?? new List>(validations).ToArray();}/// 
/// Returns a configured  instance with the given ./// 
public TOptions Create(string name){TOptions options = CreateInstance(name);foreach (IConfigureOptions setup in _setups){if (setup is IConfigureNamedOptions namedSetup){namedSetup.Configure(name, options);}else if (name == Options.DefaultName){setup.Configure(options);}}foreach (IPostConfigureOptions post in _postConfigures){post.PostConfigure(name, options);}if (_validations != null){var failures = new List();foreach (IValidateOptions validate in _validations){ValidateOptionsResult result = validate.Validate(name, options);if (result is not null && result.Failed){failures.AddRange(result.Failures);}}if (failures.Count > 0){throw new OptionsValidationException(name, typeof(TOptions), failures);}}return options;}/// 
/// Creates a new instance of options type/// 
protected virtual TOptions CreateInstance(string name){return Activator.CreateInstance();}}