前言
.NetCore中提供的选项框架，我把其理解为配置组，主要是将服务中可供配置的项提取出来，封装成一个类型；从而服务可根据应用场景进行相关配置项的设置来满足需求，其中使用了依赖注入的形式，使得更加简单、便捷；另外和配置(Configuration)系统的无缝结合，使得服务更加灵活；而对于Options我们经常在注册服务中用到，相信只要接触过.NetCore中的小伙伴都知道，在注册服务的时候，经常在参数中进行Options的配置(如下图)，可以直接的说：没有Options的服务不是好服务~~~
正文
Options模型中主要有三个核心接口类型：IOption 、IOptionsSnapshot 、IOptionsMonitor ，这里的TOptions就是指针对服务提取出来的配置项封装的类型，以下分别看看三个核心类型定义了什么？**
**
-
IOption
namespace Microsoft.Extensions.Options { // 这里TOptions 做了一个约束，必须有无参构造函数 public interface IOptionswhere TOptions : class, new() { // 这里是通过属性的方式定义TOptions TOptions Value { get; } } } -
IOptionsSnapshot
namespace Microsoft.Extensions.Options { // 这里TOptions 做了一个约束，必须有无参构造函数 public interface IOptionsSnapshot: IOptions where TOptions : class, new() { // 通过名字获取 TOptions TOptions Get(string name); } } -
IOptionsMonitor
namespace Microsoft.Extensions.Options { public interface IOptionsMonitor{ // 通过属性获取TOptions TOptions CurrentValue { get; } // 通过名称获取TOptions TOptions Get(string name); // 这是用于监听改变的，如果数据设置项改变，就会发出通知 IDisposable OnChange(Action
通过以上三种类型的定义，大概应该知道TOptions有对应的名字，根据对应的名字创建或获取TOptions，可能会问，IOption中是通过属性获取的，没有指定名字啊，其实是有的，只是名字默认为空，所以称之为默认Option；而对于IOptionsMonitor一看便知，它提供了监听改变的功能，所以后续如果需要监听改变，就可以用这个类型接口；除此，微软为三个核心类型提供了默认实现，IOptions 和IOptionsSnapshot 的默认实现为 OptionsManager ，IOptionsMonitor 的默认实现为 OptionsMonitor ，来、走进他们的世界，看看是如何实现的(进行简单的注释)：
OptionsManager
// 实现了IOptions 和IOptionsSnapshot, 同时也约束了TOptions
public class OptionsManager :IOptions, IOptionsSnapshot where TOptions : class, new()
{
// 用于专门提供TOptions实例的，同时也对TOpions进行相关初始化
private readonly IOptionsFactory _factory;
// 提高性能，将对应的TOptions实例进行缓存
private readonly OptionsCache _cache = new OptionsCache();
// 构造函数，通过依赖注入的形式，将factory进行注入
public OptionsManager(IOptionsFactory factory)
{
_factory = factory;
}
// 实现IOptions通过属性获取TOptions实例
public TOptions Value
{
get
{
// 这里通过一个默认的名字获取，只是这个名字默认为空，所以还是有名字的
return Get(Options.DefaultName);
}
}
// 实现IOptionsSnapshot通过名字获取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 : IOptionsMonitor, IDisposable where TOptions : class, new()
{
// 根据名称缓存TOptions对象
private readonly IOptionsMonitorCache _cache;
// 用于创建TOptions对象
private readonly IOptionsFactory _factory;
// 监听改变的核心
private readonly IEnumerable> _sources;
private readonly List _registrations = new List();
// 改变触发的事件
internal event Action _onChange;
// 构造函数
public OptionsMonitor(IOptionsFactory factory, IEnumerable> sources, IOptionsMonitorCache 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 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 _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);
// Dispose 方法进行解除注册的监听回调
public void Dispose() => _monitor._onChange -= OnChange;
}
}
}
通过以上代码段得知，IOptions 和IOptionsSnapshot 其实本质都是一样的，都是命名的Options，统一由IOptionsFactory创建提供TOptions对象；而对于IOptionsMonitor , 监听的本质是通过IOptionsChangeTokenSource 这个实现，每次监听到改变都把对应名称的TOptions对象移除，重新创建一个新的TOptions对象，从而获取到最新的值，其实最终改变通知的本质还是使用IChangeToken进行通知，这个可以参考之前配置的监听改变(参考这篇：跟我一起学.NetCore之配置变更监听)；
**
**
本想看完以上默认实现，就打算进行举例演示了，不再深入看代码；但是相信看到这的小伙伴肯定会问：IOptionsFactory 是怎么创建出TOptions的？ 重点都不说，差评 _~~~~~，其实我也是这么想的，所以继续再看看IOptionsFactory ；
IOptionsFactory 的默认实现是OptionsFactory ；创建TOptions我理解为三步骤，创建对象->加工对象(初始化)->验证(验证合法性)：
namespace Microsoft.Extensions.Options
{
public interface IOptionsFactory where TOptions : class, new()
{
// 接口中定义了一个创建方法，用于创建TOptions
TOptions Create(string name);
}
}
namespace Microsoft.Extensions.Options
{
// 实现IOptionsFactory接口，并约束TOptions
public class OptionsFactory : IOptionsFactory where TOptions : class, new()
{
// 初始化逻辑，初始化由IConfigureOptions和IPostConfigureOptions处理
private readonly IEnumerable> _setups;
private readonly IEnumerable> _postConfigures;
// 验证逻辑
private readonly IEnumerable> _validations;
// 构造函数
public OptionsFactory(IEnumerable> setups, IEnumerable> postConfigures) : this(setups, postConfigures, validations: null)
{ }
// 构造函数
public OptionsFactory(IEnumerable> setups, IEnumerable> postConfigures, IEnumerable> 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 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();
// 遍历验证
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 、IOptionsSnapshot 、IOptionsMonitor 三个核心类型，然后围绕三个核心类型简单看了内部实现、创建过程和监听逻辑，因为在实际应用也是围绕以上进行使用和扩展的，最终的目的是让使用不再糊涂，其实这才是终极目标啦~~~~ 下一篇就专门针对Options举例演示！！！
----------------------------------------------
一个被程序搞丑的帅小伙，关注"Code综艺圈"，识别关注跟我一起学~~~
