前言

.NetCore中提供的选项框架，我把其理解为配置组，主要是将服务中可供配置的项提取出来，封装成一个类型；从而服务可根据应用场景进行相关配置项的设置来满足需求，其中使用了依赖注入的形式，使得更加简单、便捷；另外和配置(Configuration)系统的无缝结合，使得服务更加灵活；而对于Options我们经常在注册服务中用到，相信只要接触过.NetCore中的小伙伴都知道，在注册服务的时候，经常在参数中进行Options的配置(如下图)，可以直接的说：没有Options的服务不是好服务~~~

正文

Options模型中主要有三个核心接口类型：IOption<TOptions>、IOptionsSnapshot<TOptions>、IOptionsMonitor<TOptions>，这里的TOptions就是指针对服务提取出来的配置项封装的类型，以下分别看看三个核心类型定义了什么？

• IOption<TOptions>

  namespace Microsoft.Extensions.Options
  {// 这里TOptions 做了一个约束，必须有无参构造函数public interface IOptions<out TOptions> where TOptions : class, new(){// 这里是通过属性的方式定义TOptions    TOptions Value{get;}}
  }
  

• IOptionsSnapshot<TOptions>

  namespace Microsoft.Extensions.Options
  {   // 这里TOptions 做了一个约束，必须有无参构造函数public interface IOptionsSnapshot<out TOptions> : IOptions<TOptions> where TOptions : class, new(){// 通过名字获取 TOptionsTOptions Get(string name);}
  }
  

• IOptionsMonitor<TOptions>

  namespace Microsoft.Extensions.Options
  {public interface IOptionsMonitor<out TOptions>{// 通过属性获取TOptions    TOptions CurrentValue{get;}// 通过名称获取TOptionsTOptions Get(string name);// 这是用于监听改变的，如果数据设置项改变，就会发出通知IDisposable OnChange(Action<TOptions, string> listener);}
  }

通过以上三种类型的定义，大概应该知道TOptions有对应的名字，根据对应的名字创建或获取TOptions，可能会问，IOption中是通过属性获取的，没有指定名字啊，其实是有的，只是名字默认为空，所以称之为默认Option；而对于IOptionsMonitor一看便知，它提供了监听改变的功能，所以后续如果需要监听改变，就可以用这个类型接口；除此，微软为三个核心类型提供了默认实现，IOptions<TOptions>和IOptionsSnapshot<TOptions>的默认实现为OptionsManager<TOptions>，IOptionsMonitor<TOptions>的默认实现为OptionsMonitor<TOptions>，来、走进他们的世界，看看是如何实现的(进行简单的注释)：

OptionsManager<TOptions>

// 实现了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<TOptions>

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对象，重新创建一个新TOptionsprivate 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;}// 取消注册的监听改变回调，同时移除对应的监听Tokenpublic 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<TOptions>和IOptionsSnapshot<TOptions>其实本质都是一样的，都是命名的Options，统一由IOptionsFactory创建提供TOptions对象；而对于IOptionsMonitor<TOptions>, 监听的本质是通过IOptionsChangeTokenSource<TOptions>这个实现，每次监听到改变都把对应名称的TOptions对象移除，重新创建一个新的TOptions对象，从而获取到最新的值，其实最终改变通知的本质还是使用IChangeToken进行通知，这个可以参考之前配置的监听改变(参考这篇：跟我一起学.NetCore之配置变更监听)；

本想看完以上默认实现，就打算进行举例演示了，不再深入看代码；但是相信看到这的小伙伴肯定会问：IOptionsFactory<TOptions>是怎么创建出TOptions的？ 重点都不说，差评^_^~~~~~，其实我也是这么想的，所以继续再看看IOptionsFactory<TOptions>；

IOptionsFactory<TOptions>的默认实现是OptionsFactory<TOptions>；创建TOptions我理解为三步骤，创建对象->加工对象(初始化)->验证(验证合法性)：

namespace Microsoft.Extensions.Options
{public interface IOptionsFactory<TOptions> where TOptions : class, new(){// 接口中定义了一个创建方法，用于创建TOptionsTOptions Create(string name);}
}

namespace Microsoft.Extensions.Options
{// 实现IOptionsFactory接口，并约束TOptionspublic 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);}}// 如果验证失败，就抛出异常OptionsValidationExceptionif (failures.Count > 0){throw new OptionsValidationException(name, typeof(TOptions), failures);}}// 返回实例对象return options;}}
}

对于TOptions的创建逻辑就暂时先看到这吧，如果需要再详细了解具体逻辑，可以私下进行研究；

总结

哎呀，这篇先不一一举例演示了，可能导致篇幅过长，上个WC的时间估计看不完(哈哈哈)；那么就是单纯的代码说明吗？不仅仅如此，这篇主要讲解代码的同时，其实着重凸显了IOption<TOptions>、IOptionsSnapshot<TOptions>、IOptionsMonitor<TOptions>三个核心类型，然后围绕三个核心类型简单看了内部实现、创建过程和监听逻辑，因为在实际应用也是围绕以上进行使用和扩展的，最终的目的是让使用不再糊涂，其实这才是终极目标啦~~~~ 下一篇就专门针对Options举例演示！！！

----------------------------------------------

一个被程序搞丑的帅小伙，关注"Code综艺圈"，识别关注跟我一起学~~~