使用IOptions方式获取配置选项

1.导入依赖包8.0

<PackageReference Include="Microsoft.Extensions.DependencyModel" Version="8.0.0" />
<PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />

2.配置文件①

public interface IConfigurableOptions
{
}

3.配置文件②

using Microsoft.Extensions.Configuration;

public static class ConfigurableOptions
      {

        internal static IConfiguration Configuration;

        public static void ConfigurableApplication(this IConfiguration configuration)
        {
            Configuration = configuration;
        }

        /// <summary>添加选项配置</summary>
        /// <typeparam name="TOptions">选项类型</typeparam>
        /// <param name="services">服务集合</param>
        /// <returns>服务集合</returns>
        public static IServiceCollection AddConfigurableOptions<TOptions>(this IServiceCollection services)
            where TOptions : class, IConfigurableOptions
        {
            Type optionsType = typeof(TOptions);
            string path = GetConfigurationPath(optionsType);
            services.Configure<TOptions>(Configuration.GetSection(path));

            return services;
        }

        public static IServiceCollection AddConfigurableOptions(this IServiceCollection services, Type type)
        {
            string path = GetConfigurationPath(type);
            var config = Configuration.GetSection(path);

            Type iOptionsChangeTokenSource = typeof(IOptionsChangeTokenSource<>);
            Type iConfigureOptions = typeof(IConfigureOptions<>);
            Type configurationChangeTokenSource = typeof(ConfigurationChangeTokenSource<>);
            Type namedConfigureFromConfigurationOptions = typeof(NamedConfigureFromConfigurationOptions<>);
            iOptionsChangeTokenSource = iOptionsChangeTokenSource.MakeGenericType(type);
            iConfigureOptions = iConfigureOptions.MakeGenericType(type);
            configurationChangeTokenSource = configurationChangeTokenSource.MakeGenericType(type);
            namedConfigureFromConfigurationOptions = namedConfigureFromConfigurationOptions.MakeGenericType(type);

            services.AddOptions();
            services.AddSingleton(iOptionsChangeTokenSource,
                Activator.CreateInstance(configurationChangeTokenSource, Options.DefaultName, config) ?? throw new InvalidOperationException());
            return services.AddSingleton(iConfigureOptions,
                Activator.CreateInstance(namedConfigureFromConfigurationOptions, Options.DefaultName, config) ?? throw new InvalidOperationException());
        }

        /// <summary>获取配置路径</summary>
        /// <param name="optionsType">选项类型</param>
        /// <returns></returns>
        public static string GetConfigurationPath(Type optionsType)
        {
            var endPath = new[] { "Option", "Options" };
            var configurationPath = optionsType.Name;
            foreach (var s in endPath)
            {
                if (configurationPath.EndsWith(s))
                {
                    return configurationPath[..^s.Length];
                }
            }

            return configurationPath;
        }
      }

4.配置模型文件

/// <summary>
/// Redis缓存配置选项
/// </summary>
public class RedisOptions : IConfigurableOptions
{
    /// <summary>
    /// 是否启用
    /// </summary>
    public bool Enable { get; set; }

    /// <summary>
    /// redis连接
    /// </summary>
    public string ConnectionString { get; set; }

    /// <summary>
    /// 键值前缀
    /// </summary>
    public string InstanceName { get; set; }
}

5.配置服务

public static class AllOptionRegister
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="services"></param>
    /// <exception cref="ArgumentNullException"></exception>
    public static void AddAllOptionRegister(this IServiceCollection services)
    {
        if (services == null) throw new ArgumentNullException(nameof(services));

        foreach (var optionType in typeof(ConfigurableOptions).Assembly.GetTypes().Where(s =>
                     !s.IsInterface && typeof(IConfigurableOptions).IsAssignableFrom(s)))
        {
            services.AddConfigurableOptions(optionType);
        }
    }
}

6.在program.cs文件注册服务

// 配置IOptions方式获取配置
ConfigurableOptions.ConfigurableApplication(builder.Configuration);
builder.Services.AddAllOptionRegister();

7.在control层使用

private readonly IOptions<RedisOptions> _redisOptions;

public WeatherForecastController(ILogger<WeatherForecastController> logger,
    IMapper mapper,
    IBaseService<Role, RoleVo> roleService,
    IOptions<RedisOptions> options)
{
    _logger = logger;
    _mapper = mapper;
    _roleService = roleService;
    _redisOptions = options;
}

var redisOptions = _redisOptions.Value;
Console.WriteLine(JsonConvert.SerializeObject(redisOptions));