如山 发表于 2023-12-3 02:40:51

Options选项

选项用来提供对相关设置的强类型访问,读取配置首选使用选项模式。选项无法脱离容器使用,依赖容器,实现了选项不同的访问方式。选项模式使用了泛型包装器,因此具备了如下优点:

[*]不需要显示注册选项具体类型,只需要将泛型包装器注入到容器中;
[*]对于选项实例的评估推迟到获取IOptions.Value时进行,而不是在注入时进行,这样就可以获取不同生命周期的选项;
[*]可以对选项进行泛型约束;
选项注入

选项模式向容器中注入了三种类型的选项泛型包装器:IOptions,IOptionsSnapshot,IOptionsMonitor。其中IOptionsSnapshot被注册为Scoped。注入了IOptionsFactory泛型选项工厂,用来创建选项实例。注入了IOptionsMonitorCache,由IOptionsMonitor用于缓存泛型实例。
public static IServiceCollection AddOptions(this IServiceCollection services)
{
    if (services == null)
      throw new ArgumentNullException(nameof(services));

    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;
}选项不同生命周期

不同类型的选项接口功能不同:

[*]IOptions:实现类为UnnamedOptionsManager,其中TOptions字段保存选项实例(不支持命名选项)。在首次获取Value时,会调用工厂创建选项实例。因为被注册为单例,因此无法识别配置修改。
[*]IOptionsSnapshot:实现类为OptionsManager,其中OptionsCache字段(私有,非容器获取)保存选项实例(支持命名选项)。被注册为范围,在范围内首次获取Value时,会调用工厂创建选项实例,并将其保存到私有的OptionsCache中,在范围内选项值不变,不同范围内选项值根据获取时配置文件的不同而不同。
[*]IOptionsMonitor:实现类为OptionsMonitor,其中IOptionsMonitorCache字段,该字段的值是从容器中解析的,用来缓存选项实例。OptionsMonitor还注入了IOptionsChangeTokenSource列表,可以监听配置源的修改。当监听到修改时,调用工厂重新创建选项以刷新选项值。
internal sealed class UnnamedOptionsManager<[DynamicallyAccessedMembers(
    Options.DynamicallyAccessedMembers)] TOptions> : IOptions<TOptions>
    where TOptions : class
{
    private readonly IOptionsFactory<TOptions> _factory;
    private volatile object _syncObj;
    private volatile TOptions _value;

    public UnnamedOptionsManager(IOptionsFactory<TOptions> 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< TOptions>
    : IOptions<TOptions>, IOptionsSnapshot<TOptions>
    where TOptions : class
{
    private readonly IOptionsFactory<TOptions> _factory;
    private readonly OptionsCache<TOptions> _cache = new OptionsCache<TOptions>();
      
    public OptionsManager(IOptionsFactory<TOptions> factory)
    {
      _factory = factory;
    }

    public TOptions Value => Get(Options.DefaultName);

    public virtual TOptions Get(string name)
    {
      name = name ?? Options.DefaultName;

      if (!_cache.TryGetValue(name, out TOptions options))
      {
            IOptionsFactory<TOptions> localFactory = _factory;
            string localName = name;
            options = _cache.GetOrAdd(name, () => localFactory.Create(localName));
      }

      return options;
    }
}public class OptionsMonitor< TOptions>
    : IOptionsMonitor<TOptions>, IDisposable
    where TOptions : class
{
    private readonly IOptionsMonitorCache<TOptions> _cache;
    private readonly IOptionsFactory<TOptions> _factory;
    private readonly List<IDisposable> _registrations = new List<IDisposable>();
    internal event Action<TOptions, string> _onChange;

    public OptionsMonitor(IOptionsFactory<TOptions> factory,
      IEnumerable<IOptionsChangeTokenSource<TOptions>> sources, IOptionsMonitorCache<TOptions> cache)
    {
      _factory = factory;
      _cache = cache;

      void RegisterSource(IOptionsChangeTokenSource<TOptions> source)
      {
            IDisposable registration = ChangeToken.OnChange(
                      () => source.GetChangeToken(),
                      (name) => InvokeChanged(name),
                      source.Name);

            _registrations.Add(registration);
      }
      
      // 此处简写
      foreach (IOptionsChangeTokenSource<TOptions> 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);
    }

    public TOptions CurrentValue
    {
      get => Get(Options.DefaultName);
    }

    public virtual TOptions Get(string name)
    {
      name = name ?? Options.DefaultName;
      return _cache.GetOrAdd(name, () => _factory.Create(name));
    }

    public IDisposable OnChange(Action<TOptions, string> listener)
    {
      var disposable = new ChangeTrackerDisposable(this, listener);
      _onChange += disposable.OnChange;
      return disposable;
    }

    public void Dispose()
    {
      foreach (IDisposable registration in _registrations)
      {
            registration.Dispose();
      }

      _registrations.Clear();
    }
}选项配置

选项模式提供了IConfigureOptions、IConfigureNamedOptions和IPostConfigureOptions接口,用来对选项进行配置。IConfigureNamedOptions继承了IConfigureOptions接口,增加了命名选项配置功能。这三个接口中都有一个对选项配置的方法,将接口注入到容器中,当调用工厂创建选项时,会调用接口中的配置方法对选项进行配置。首先会调用IConfigureOptions、IConfigureNamedOptions接口中的配置方法,然后调用IPostConfigureOptions接口中的配置方法。
// OptionsFactory<>
public TOptions Create(string name)
{
    TOptions options = CreateInstance(name);
    foreach (IConfigureOptions<TOptions> setup in _setups)
    {
      if (setup is IConfigureNamedOptions<TOptions> namedSetup)
            namedSetup.Configure(name, options);
      else if (name == Options.DefaultName)
            setup.Configure(options);
    }
    foreach (IPostConfigureOptions<TOptions> post in _postConfigures)
    {
      post.PostConfigure(name, options);
    }

    // 选项验证...

    return options;
}

protected virtual TOptions CreateInstance(string name)
{
    return Activator.CreateInstance<TOptions>();
}选项验证

选项模式提供了IValidateOptions接口,包含一个Validate方法对选项进行验证。将接口注入容器中,当调用工厂创建选项时,会调用接口中的Validate方法对选项进行验证。
// OptionsFactory<>
public TOptions Create(string name)
{
    TOptions options = CreateInstance(name);
    // 选项配置...

    if (_validations.Length > 0)
    {
      var failures = new List<string>();
      foreach (IValidateOptions<TOptions> 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;
}如果需要为选项添加验证,实现IValidateOptions接口并注入到容器即可:
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton
    <IValidateOptions<SettingsOptions>, ValidateSettingsOptions>());也可以添加DataAnnotations验证,调用ValidateDataAnnotations扩展方法即可,该方法定义在 Microsoft.Extensions.Options.DataAnnotations中。需要先调用AddOptions扩展方法创建OptionsBuilder:
builder.Services.AddOptions<SettingsOptions>()
    .Bind(Configuration.GetSection(SettingsOptions.ConfigurationSectionName))
    .ValidateDataAnnotations();绑定配置

通过如下扩展方法将选项绑定到配置:
builder.Services.Configure<SettingsOptions>(builder.Configuration.GetSection("Settings"));绑定到配置是通过IConfiguration.Bind()扩展方法实现的,同时,也添加了对配置修改的监听:
public static IServiceCollection Configure< TOptions>(this IServiceCollection services, string name, IConfiguration config, Action<BinderOptions> configureBinder) where TOptions : class
{
    if (services == null)
      throw new ArgumentNullException(nameof(services));

    if (config == null)
      throw new ArgumentNullException(nameof(config));

    services.AddOptions();
    services.AddSingleton<IOptionsChangeTokenSource<TOptions>>(
      new ConfigurationChangeTokenSource<TOptions>(name, config));
    return services.AddSingleton<IConfigureOptions<TOptions>>(
      new NamedConfigureFromConfigurationOptions<TOptions>(name, config, configureBinder));
}
来源:https://www.cnblogs.com/louzixl/archive/2023/12/03/17872541.html
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!
页: [1]
查看完整版本: Options选项