浅析.netcore中的Configuration具体使用

不管是.net还是.netcore项目，我们都少不了要读取配置文件，在.net中项目，配置一般就存放在web.config中，但是在.netcore中我们新建的项目根本就看不到web.config，取而代之的是appsetting.json。

新建一个webapi项目，可以在startup中看到一个iconfiguration，通过框架自带的ioc使用构造函数进行实例化，在iconfiguration中我们发现直接就可以读取到appsetting.json中的配置项了，如果在控制器中需要读取配置，也是直接通过构造

函数就可以实例化iconfiguration对象进行配置的读取。下面我们试一下运行的效果，在appsetting.json添加一个配置项，在action中可以进行访问。

添加其他配置文件

那我们的配置项是不是只能写在appsetting.json中呢？当然不是，下面我们看看如何添加其他的文件到配置项中，根据官网教程，我们可以使用configureappconfiguration实现。

首先我们在项目的根目录新建一个config.json，然后在其中随意添加几个配置，然后在program.cs中添加高亮显示的部分，这样很简单的就将我们新增的json文件中的配置加进来了，然后在程序中就可以使用iconfiguration进行访问config.json中的配置项了。

public class program
{
    public static void main(string[] args)
    {
        createhostbuilder(args).build().run();
    }

    public static ihostbuilder createhostbuilder(string[] args) =>
        host.createdefaultbuilder(args)
            .configureappconfiguration(configure => {               
                configure.addjsonfile("config.json");  //无法热修改

            })
            .configurewebhostdefaults(webbuilder =>
            {
                webbuilder.usestartup<startup>();
            });
}

但是这个无法在配置项修改后读取到最新的数据，我们可以调用重载方法configure.addjsonfile("config.json",true,reloadonchange:true)实现热更新。

除了添加json文件外，我们还可以使用addxmlfile添加xml文件，使用addinmemorycollection添加内存配置

public static ihostbuilder createhostbuilder(string[] args) =>
    host.createdefaultbuilder(args)
        .configureappconfiguration((context,configure) => {
            dictionary<string, string> memoryconfig = new dictionary<string, string>();
            memoryconfig.add("memorykey1", "m1");
            memoryconfig.add("memorykey2", "m2");
    
            configure.addinmemorycollection(memoryconfig);
    
        })
        .configurewebhostdefaults(webbuilder =>
        {
            webbuilder.usestartup<startup>();
        });

源码解读：

在自动生成的项目中，我们没有配置过如何获取配置文件，那.netcore框架是怎么知道要appsetting.json配置文件的呢？我们通过查看源码我们就可以明白其中的道理。

host.createdefaultbuilder(args)    
    .configurewebhostdefaults(webbuilder =>
    {
        webbuilder.usestartup<startup>();
    });


//createdefaultbuilder源码
public static ihostbuilder createdefaultbuilder(string[] args)
{
    var builder = new hostbuilder();

    builder.usecontentroot(directory.getcurrentdirectory());
    builder.configurehostconfiguration(config =>
    {
        config.addenvironmentvariables(prefix: "dotnet_");
        if (args != null)
        {
            config.addcommandline(args);
        }
    });

    builder.configureappconfiguration((hostingcontext, config) =>
    {
        var env = hostingcontext.hostingenvironment;

        config.addjsonfile("appsettings.json", optional: true, reloadonchange: true)
              .addjsonfile($"appsettings.{env.environmentname}.json", optional: true, reloadonchange: true);

        if (env.isdevelopment() && !string.isnullorempty(env.applicationname))
        {
            var appassembly = assembly.load(new assemblyname(env.applicationname));
            if (appassembly != null)
            {
                config.addusersecrets(appassembly, optional: true);
            }
        }

        config.addenvironmentvariables();

        if (args != null)
        {
            config.addcommandline(args);
        }
    });
    
    ....

    return builder;
}

怎么样？是不是很有意思，在源码中我们看到在program中构建host的时候就会调用configureappconfiguration对应用进行配置，会读取appsetting.json文件，并且会根据环境变量加载不同环境的appsetting，同时还可以看到应用不仅添加了

appsetting的配置，而且添加了从环境变量、命令行传入参数的支持，对于addusersecrets支持读取用户机密文件中的配置，这个在存储用户机密配置的时候会用到。

那为什么我们可以通过再次调用configureappconfiguration去追加配置信息，而不是覆盖呢？我们同样可以在源码里面找到答案。

public static void main(string[] args)
{
    createhostbuilder(args).build().run();
}
//以下为部分源码
private list<action<hostbuildercontext, iconfigurationbuilder>> _configureappconfigactions = new list<action<hostbuildercontext, iconfigurationbuilder>>();private iconfiguration _appconfiguration;

public ihostbuilder configureappconfiguration(action<hostbuildercontext, iconfigurationbuilder> configuredelegate)
{
    _configureappconfigactions.add(configuredelegate ?? throw new argumentnullexception(nameof(configuredelegate)));
    return this;
}


public ihost build()
{
    ...

    buildappconfiguration();

    ...
}

private void buildappconfiguration()
{
    var configbuilder = new configurationbuilder()
        .setbasepath(_hostingenvironment.contentrootpath)
        .addconfiguration(_hostconfiguration, shoulddisposeconfiguration: true);

    foreach (var buildaction in _configureappconfigactions)
    {
        buildaction(_hostbuildercontext, configbuilder);
    }
    _appconfiguration = configbuilder.build();
    _hostbuildercontext.configuration = _appconfiguration;
}

框架声明了一个list<action<hostbuildercontext, iconfigurationbuilder>>，我们每次调用configureappconfiguration都是往这个集合中添加元素，等到main函数调用build的时候会触发configurationbuilder，将集合中的所有元素进行循环追加

到configurationbuilder，最后就形成了我们使用的iconfiguration，这样一看对于.netcore中iconfiguration是怎么来的就很清楚了。

读取层级配置项

如果需要读取配置文件中某个层级的配置应该怎么做呢？也很简单，使用iconfiguration["key:childkey..."]

比如有这样一段配置：

"config_key2": {
    "config_key2_1": "config_key2_1",
    "config_key2_2": "config_key2_2"
  }

可以使用iconfiguration["config_key2:config_key2_1"]来获取到config_key2_1的配置项，如果config_key2_1下还有子配置项childkey，依然可以继续使用:childkey来获取

选项模式获取配置项

选项模式使用类来提供对相关配置节的强类型访问，将配置文件中的配置项转化为poco模型，可为开发人员编写代码提供更好的便利和易读性

我们添加这样一段配置：

"student": {
    "sno": "sno",
    "sname": "sname",
    "sage": 18,
    "id": "001"
  }

接下来我们定义一个student的model类

public class student
{
    private string _id;
    public const string name = "student";
    private string id { get; set; }
    public string sno { get; set; }
    public string sname { get; set; }
    public int sage { get; set; }
}

可以使用多种方式来进行绑定：

1、使用bind方式绑定

student student = new student();
_configuration.getsection(student.name).bind(student);

2、使用get方式绑定

var student1 = _configuration.getsection(student.name).get<student>(binderoptions=> {
　　binderoptions.bindnonpublicproperties = true;
});

get方式和bind方式都支持添加一个action<binderoptions>的重载，通过这个我们配置绑定时的一些配置，比如非公共属性是否绑定（默认是不绑定的），但是get比bind使用稍微方便一些，如果需要绑定集合也是一样的道理，将student

替换成list<student>。

3、全局方式绑定

前两种方式只能在局部生效，要想做一次配置绑定，任何地方都生效可用，我们可以使用全局绑定的方式，全局绑定在startup.cs中定义

services.configure<student>(configuration.getsection(student.name));

此方式会使用选项模式进行配置绑定，并且会注入到ioc中，在需要使用的地方可以在构造函数中进行实例化

private readonly ilogger<weatherforecastcontroller> _logger;
private readonly iconfiguration _configuration;
private readonly student _student;

public weatherforecastcontroller(ilogger<weatherforecastcontroller> logger, iconfiguration configuration, ioptions<student> student)
{
    _logger = logger;
    _configuration = configuration;
    _student = student.value;
}

命名选项的使用

对于不同的配置节，包含的配置项一样时，我们在使用选项绑定的时候无需定义和注入两个类，可以在绑定时指定名称，比如下面的配置：

"root": {
  "child1": {
    "child_1": "child1_1",
    "child_2": "child1_2"
  },
  "child2": {
    "child_1": "child2_1",
    "child_2": "child2_2"
  }
}public class root{　　public string child_1{get;set;}　　public string child_2{get;set;}}

services.configure<root>("child1",configuration.getsection("root:child1"));
services.configure<root>("child2", configuration.getsection("root:child2"));

private readonly ilogger<weatherforecastcontroller> _logger;
private readonly iconfiguration _configuration;
private readonly student _student;
private readonly root _child1;
private readonly root _child2;

public weatherforecastcontroller(ilogger<weatherforecastcontroller> logger, iconfiguration configuration, ioptions<student> student,ioptionssnapshot<root> root)
{
    _logger = logger;
    _configuration = configuration;
    _student = student.value;
    _child1 = root.get("child1");
    _child2 = root.get("child2");
}

到此这篇关于浅析.netcore中的configuration具体使用的文章就介绍到这了,更多相关.net core configuration内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！