跟我一起学.NetCore之选项(Options)核心类型简介
前言
.NetCore中提供的选项框架，我把其理解为配置组，主要是将服务中可供配置的项提取出来，封装成一个类型；从而服务可根据应用场景进行相关配置项的设置来满足需求，其中使用了依赖注入的形式，使得更加简单、便捷；另外和配置(Configuration)系统的无缝结合，使得服务更加灵活；而对于Options我们经常在注册服务中用到，相信只要接触过.NetCore中的小伙伴都知道，在注册服务的时候，经常在参数中进行Options的配置(如下图)，可以直接的说：没有Options的服务不是好服务~~~
正文
Options模型中主要有三个核心接口类型：IOption
**
-
IOption
namespace Microsoft.Extensions.Options { // 这里TOptions 做了一个约束，必须有无参构造函数 public interface IOptions<out TOptions> where TOptions : class, new() { // 这里是通过属性的方式定义TOptions TOptions Value { get; } } } -
IOptionsSnapshot
namespace Microsoft.Extensions.Options { // 这里TOptions 做了一个约束，必须有无参构造函数 public interface IOptionsSnapshot<out TOptions> : IOptions<TOptions> where TOptions : class, new() { // 通过名字获取 TOptions TOptions Get(string name); } } -
IOptionsMonitor
namespace Microsoft.Extensions.Options { public interface IOptionsMonitor<out TOptions> { // 通过属性获取TOptions TOptions CurrentValue { get; } // 通过名称获取TOptions TOptions Get(string name); // 这是用于监听改变的，如果数据设置项改变，就会发出通知 IDisposable OnChange(Action<TOptions, string> listener); } }
通过以上三种类型的定义，大概应该知道TOptions有对应的名字，根据对应的名字创建或获取TOptions，可能会问，IOption中是通过属性获取的，没有指定名字啊，其实是有的，只是名字默认为空，所以称之为默认Option；而对于IOptionsMonitor一看便知，它提供了监听改变的功能，所以后续如果需要监听改变，就可以用这个类型接口；除此，微软为三个核心类型提供了默认实现，IOptions
OptionsManager
// 实现了IOptions<TOptions> 和IOptionsSnapshot<TOptions>, 同时也约束了TOptions
public class OptionsManager<TOptions> :IOptions<TOptions>, IOptionsSnapshot<TOptions> where TOptions : class, new()
{
// 用于专门提供TOptions实例的，同时也对TOpions进行相关初始化
private readonly IOptionsFactory<TOptions> _factory;
// 提高性能，将对应的TOptions实例进行缓存
private readonly OptionsCache<TOptions> _cache = new OptionsCache<TOptions>();
// 构造函数，通过依赖注入的形式，将factory进行注入
public OptionsManager(IOptionsFactory<TOptions> factory)
{
_factory = factory;
}
// 实现IOptions<TOptions>通过属性获取TOptions实例
public TOptions Value
{
get
{
// 这里通过一个默认的名字获取，只是这个名字默认为空，所以还是有名字的
return Get(Options.DefaultName);
}
}
// 实现IOptionsSnapshot<TOptions>通过名字获取TOptions
public virtual TOptions Get(string name)
{
name = name ?? Options.DefaultName;
// 如果缓存中没有，就通过传入的Action进行创建并加入到缓存中
return _cache.GetOrAdd(name, () => _factory.Create(name));
}
}
// 定义的 TOptions默认名称
public static class Options
{
public static readonly string DefaultName = string.Empty;
}
OptionsMonitor
namespace Microsoft.Extensions.Options
{
// 实现IOptionsMonitor ,对TOpitons 进行约束
public class OptionsMonitor<TOptions> : IOptionsMonitor<TOptions>, IDisposable where TOptions : class, new()
{
// 根据名称缓存TOptions对象
private readonly IOptionsMonitorCache<TOptions> _cache;
// 用于创建TOptions对象
private readonly IOptionsFactory<TOptions> _factory;
// 监听改变的核心
private readonly IEnumerable<IOptionsChangeTokenSource<TOptions>> _sources;
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;
_sources = sources;
_cache = cache;
// 注册改变回调，用于监听
foreach (var source in _sources)
{
var registration = ChangeToken.OnChange(
() => source.GetChangeToken(),
(name) => InvokeChanged(name),
source.Name);
_registrations.Add(registration);
}
}
// 这个方法是重点，如果发生改变，移除之前的TOptions对象，重新创建一个新TOptions
private void InvokeChanged(string name)
{
name = name ?? Options.DefaultName;
// 根据名字移除TOpitons对象
_cache.TryRemove(name);
// 重新根据名称获取对象
var options = Get(name);
if (_onChange != null)
{
_onChange.Invoke(options, name);
}
}
// 获取默认的TOptions对象
public TOptions CurrentValue
{
get => Get(Options.DefaultName);
}
// 根据名称获取TOptions对象，如果没有就利用OptionsFactory创建TOptions对象
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;
}
// 取消注册的监听改变回调，同时移除对应的监听Token
public void Dispose()
{
foreach (var registration in _registrations)
{
registration.Dispose();
}
_registrations.Clear();
}
// 内部类
internal class ChangeTrackerDisposable : IDisposable
{
private readonly Action<TOptions, string> _listener;
private readonly OptionsMonitor<TOptions> _monitor;
public ChangeTrackerDisposable(OptionsMonitor<TOptions> monitor, Action<TOptions, string> listener)
{
_listener = listener;
_monitor = monitor;
}
// 触发改变时调用对应注册的回调
public void OnChange(TOptions options, string name) => _listener.Invoke(options, name);
// Dispose 方法进行解除注册的监听回调
public void Dispose() => _monitor._onChange -= OnChange;
}
}
}
通过以上代码段得知，IOptions
**
**
本想看完以上默认实现，就打算进行举例演示了，不再深入看代码；但是相信看到这的小伙伴肯定会问：IOptionsFactory
IOptionsFactory
namespace Microsoft.Extensions.Options
{
public interface IOptionsFactory<TOptions> where TOptions : class, new()
{
// 接口中定义了一个创建方法，用于创建TOptions
TOptions Create(string name);
}
}
namespace Microsoft.Extensions.Options
{
// 实现IOptionsFactory接口，并约束TOptions
public class OptionsFactory<TOptions> : IOptionsFactory<TOptions> where TOptions : class, new()
{
// 初始化逻辑，初始化由IConfigureOptions和IPostConfigureOptions处理
private readonly IEnumerable<IConfigureOptions<TOptions>> _setups;
private readonly IEnumerable<IPostConfigureOptions<TOptions>> _postConfigures;
// 验证逻辑
private readonly IEnumerable<IValidateOptions<TOptions>> _validations;
// 构造函数
public OptionsFactory(IEnumerable<IConfigureOptions<TOptions>> setups, IEnumerable<IPostConfigureOptions<TOptions>> postConfigures) : this(setups, postConfigures, validations: null)
{ }
// 构造函数
public OptionsFactory(IEnumerable<IConfigureOptions<TOptions>> setups, IEnumerable<IPostConfigureOptions<TOptions>> postConfigures, IEnumerable<IValidateOptions<TOptions>> validations)
{
_setups = setups;
_postConfigures = postConfigures;
_validations = validations;
}
// 创建TOptions的核心方法，传入名称，如果没名称，默认是空
public TOptions Create(string name)
{
// 1 根据传入的TOptions创建对象，这里用无参构造函数，所以之前需要对TOptions进行约束
var options = new TOptions();
// 2 初始化
foreach (var setup in _setups)
{
// 根据传入的名字是否为默认名称选择不同的加工方法
if (setup is IConfigureNamedOptions<TOptions> namedSetup)
{
namedSetup.Configure(name, options);
}
else if (name == Options.DefaultName)
{
setup.Configure(options);
}
}
// IPostConfigureOptions对Options加工
foreach (var post in _postConfigures)
{
post.PostConfigure(name, options);
}
// 进行验证， 如果不传入验证规则，则代表不进行验证
if (_validations != null)
{
// 存放验证失败的错误消息
var failures = new List<string>();
// 遍历验证
foreach (var validate in _validations)
{
// 进行验证
var result = validate.Validate(name, options);
// 如果验证失败
if (result.Failed)
{
// 将验证失败错误信息加入到列表中
failures.AddRange(result.Failures);
}
}
// 如果验证失败，就抛出异常OptionsValidationException
if (failures.Count > 0)
{
throw new OptionsValidationException(name, typeof(TOptions), failures);
}
}
// 返回实例对象
return options;
}
}
}
对于TOptions的创建逻辑就暂时先看到这吧，如果需要再详细了解具体逻辑，可以私下进行研究；
总结
哎呀，这篇先不一一举例演示了，可能导致篇幅过长，上个WC的时间估计看不完(哈哈哈)；那么就是单纯的代码说明吗？不仅仅如此，这篇主要讲解代码的同时，其实着重凸显了IOption
----------------------------------------------
一个被程序搞丑的帅小伙，关注"Code综艺圈"，识别关注跟我一起学~~~
