• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

跟我一起学.NetCore之选项(Options)核心类型简介

开发技术 开发技术 8个月前 (08-21) 91次浏览

前言

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

跟我一起学.NetCore之选项(Options)核心类型简介

正文

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

  • 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和IOptionsSnapshot的默认实现为OptionsManager,IOptionsMonitor的默认实现为OptionsMonitor,来、走进他们的世界,看看是如何实现的(进行简单的注释):

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

**
**

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

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

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、IOptionsSnapshot、IOptionsMonitor三个核心类型,然后围绕三个核心类型简单看了内部实现、创建过程和监听逻辑,因为在实际应用也是围绕以上进行使用和扩展的,最终的目的是让使用不再糊涂,其实这才是终极目标啦~~~~ 下一篇就专门针对Options举例演示!!!

———————————————-

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

跟我一起学.NetCore之选项(Options)核心类型简介


程序员灯塔
转载请注明原文链接:跟我一起学.NetCore之选项(Options)核心类型简介
喜欢 (0)