如果您想直接使用ChildSettings而不通过AppSettings对象，则必须将ChildSettings注册为DI配置中的单独条目，如下所示：
services.Configure<ChildSettings>(_configuration.GetSection("AppSettings:ChildSettings"));
但是如果你想这样做，也许你可以只在appsettings.json文件的根目录下设置ChildSettings，你不需要把你的设置放在一个名为AppSettings的部分。

配置所有options automatically

PM> Install-Package Register.Options.Asp.Net.Core

• 启动.cs*

public void ConfigureServices(IServiceCollection services)
{
    services.ConfigureOptionsFromAssemblies(configuration, new List<Assembly>()
    {
        typeof(AppSettings).Assembly
    });

    ...
}

• 应用程序设置.json*

{
    "ChildSettings": {
        "ChildProperty": "Value"
    }       
}

• 免责声明package的作者 *

可以通过实现自定义IOptionsFactory〈〉来实现。
可复制粘贴代码：
用法：services.AddRecursiveOptions<AppSettings>(Configuration);

public static class RecursiveOptionsFactoryExtensions
{
    public static void AddRecursiveOptions<TAppSettings>(this IServiceCollection services, IConfiguration configuration)
        where TAppSettings : class
    {
        var appSettings = configuration.Get<TAppSettings>();
        services.AddSingleton<IAppSettingsProvider>(
            new AppSettingsProvider<TAppSettings>(appSettings!));
        services.AddTransient(typeof(IOptionsFactory<>), typeof(RecursiveResolvingOptionsFactory<>));
        services.Configure<TAppSettings>(configuration);
    }

    private interface IAppSettingsProvider
    {
        public object AppSettings { get; }
    }

    private class AppSettingsProvider<TAppSettings> : IAppSettingsProvider
    {
        public object AppSettings { get; }

        public AppSettingsProvider([DisallowNull] TAppSettings appSettings)
        {
            AppSettings = appSettings ?? throw new ArgumentNullException(nameof(appSettings));
        }
    }

    private class RecursiveResolvingOptionsFactory<TOptions> : IOptionsFactory<TOptions> where TOptions : class, new()
    {
        private readonly IEnumerable<IConfigureOptions<TOptions>> _setups;
        private readonly IEnumerable<IPostConfigureOptions<TOptions>> _postConfigures;
        private readonly IEnumerable<IValidateOptions<TOptions>>? _validations;
        private readonly object _appSettings;

        public RecursiveResolvingOptionsFactory(
            IEnumerable<IConfigureOptions<TOptions>> setups,
            IEnumerable<IPostConfigureOptions<TOptions>> postConfigures,
            IEnumerable<IValidateOptions<TOptions>>? validations,
            IAppSettingsProvider appSettings)
        {
            _setups = setups;
            _postConfigures = postConfigures;
            _validations = validations;
            _appSettings = appSettings.AppSettings;
        }

        private static TOptions? FindOptionsRecursively(object source)
        {
            var properties = source.GetType().GetProperties();
            foreach (var propertyInfo in properties)
            {
                var value = propertyInfo.GetValue(source);
                if (propertyInfo.PropertyType == typeof(TOptions))
                {
                    return (TOptions) value!;
                }

                if (!propertyInfo.PropertyType.IsClass || propertyInfo.PropertyType == typeof(string))
                {
                    continue;
                }

                var found = FindOptionsRecursively(value!);
                if (found != null)
                {
                    return found;
                }
            }

            return null;
        }

        public TOptions Create(string name)
        {
            // instead of creating default instance, like Microsoft.Extensions.Options.OptionsFactory<> does,
            // try finding if it is a property of AppSettings first
            var options = FindOptionsRecursively(_appSettings);
            if (options != null) return options;

            options = new TOptions();

            // copied from Microsoft.Extensions.Options.OptionsFactory<>
            foreach (IConfigureOptions<TOptions> setup in _setups)
            {
                if (setup is IConfigureNamedOptions<TOptions> configureNamedOptions)
                    configureNamedOptions.Configure(name, options);
                else if (name == Options.DefaultName)
                    setup.Configure(options);
            }

            foreach (IPostConfigureOptions<TOptions> postConfigure in _postConfigures)
                postConfigure.PostConfigure(name, options);
            if (_validations != null)
            {
                List<string> failureMessages = new List<string>();
                foreach (IValidateOptions<TOptions> validation in _validations)
                {
                    ValidateOptionsResult validateOptionsResult = validation.Validate(name, options);
                    if (validateOptionsResult.Failed)
                        failureMessages.AddRange(validateOptionsResult.Failures);
                }

                if (failureMessages.Count > 0)
                    throw new OptionsValidationException(name, typeof(TOptions), failureMessages);
            }

            return options;
        }
    }
}