ASP.NET Core 中的配置

前言

配置在我们开发过程中必不可少，ASP.NET中的配置在 Web.config 中。也可配置在如：JSON、XML、数据库等(但ASP.NET并没提供相应的模块和方法)。

在ASP.NET Core中Web.config已经不存在了(但如果托管到 IIS 的时候可以使用 web.config 配置 IIS)，

而是用appsettings.json和appsettings.(Development、Staging、Production).json配置文件

(可以理解为ASP.NET中的Web.config和Web.Release.config的关系)。

下面我们一起看下ASP.NET Core 中的配置

基础用法

HomeController.cs：

[ApiController]
public class HomeController : ControllerBase
{
    private readonly IConfiguration _configuration;
    public HomeController(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    [HttpGet("/")]
    public dynamic Index()
    {
        return JsonConvert.SerializeObject(new
        {
            ConnectionString = _configuration["ConnectionString"],
            Child1 = _configuration["Parent:Child1"],
            Grandchildren = _configuration["Parent:Child2:Grandchildren"]
        });
    }
}

返回结果：

{
    "ConnectionString": "data source=.;initial catalog=TEST;user id=sa",
    "Child1": "child",
    "Grandchildren": "grandchildren"
}

对应appsettings.json的值：

{
    "ConnectionString": "data source=.;initial catalog=TEST;user id=sa;password=123",
    "Parent": {
        "Child1": "child1",
        "Child2": "child2"
    }
}

需要注意的：

  • 键不区分大小写。 例如，ConnectionString 和 connectionstring 被视为等效键。
  • 如果键名相同(包含所有加载的配置文件),以最后一个值为准。

    所以appsettings.(Development、Staging、Production).json会覆盖appsettings.json的配置信息。

    • 多层级用:来分割,但如果是环境变量则存在跨平台问题 查看具体细节
    • 上面这种写法是没缓存的即：appsettings.json修改后,获取的值会立即改变

绑定到对象 IOptions<TestOptions>

对于_configuration["Parent:Child2:Grandchildren"]的写法对程序员来说肯定很反感,下面我们看下把配置文件绑定到对象中。

  1. 首先把 JSON 对象转换成对象

    public class TestOptions
{
    public string ConnectionString { get; set; }
    public Parent Parent { get; set; }
}
public class Parent
{
    public string Child1 { get; set; }
    public Child2 Child2 { get; set; }
}
public class Child2
{
    public string GrandChildren { get; set; }
}
  2. 在Startup.cs的ConfigureServices方法添加代码： 
    services.Configure<TestOptions>(Configuration);
  3. HomeController.cs： 
    [ApiController]
public class HomeController : ControllerBase
{
    private readonly IOptions<TestOptions> _options;

    public HomeController(IOptions<TestOptions> options)
    {
        _options = options;
    }

    [HttpGet("options")]
    public string Options()
    {
        return JsonConvert.SerializeObject(_options);
    }
}

    返回的结果如下：

    {
"Value": {
    "ConnectionString": "data source=.;initial catalog=TEST;user id=sa",
        "Parent": {
        "Child1": "child",
            "Child2": {
            "GrandChildren": "grandchildren"
            }
        }
    }
}

发现

  • 如果我们修改appsettings.json，然后刷新页面，会发现值并没用变
  • 我们发现根节点是Value

    根据上面 2 个问题我们去看源代码：

    首先找到这句：

    services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptions<>), typeof(OptionsManager<>)));

    我们去看OptionsManager方法：

    public class OptionsManager<TOptions> : IOptions<TOptions>, IOptionsSnapshot<TOptions> where TOptions : class, new()
{
    private readonly IOptionsFactory<TOptions> _factory;
    // 注解: _cache 为 ConcurrentDictionary<string, Lazy<TOptions>>()
    // 不知道注意到上面注入方法没，用的是 Singleton 单例,所以更新配置文件后没及时更新
    private readonly OptionsCache<TOptions> _cache = new OptionsCache<TOptions>();

    public OptionsManager(IOptionsFactory<TOptions> factory)
    {
        _factory = factory;
    }

    /// <summary>
    /// TOptions的默认配置实例
    /// 这里就是为什么根节点为Value
    /// </summary>
    public TOptions Value
    {
        get
        {
            return Get(Options.DefaultName);
        }
    }

    /// <summary>
    /// 该方法在 IOptionsSnapshot 接口中
    /// </summary>
    public virtual TOptions Get(string name)
    {
        name = name ?? Options.DefaultName;

        // Store the options in our instance cache
        return _cache.GetOrAdd(name, () => _factory.Create(name));
    }
}

绑定到对象 IOptionsSnapshot<TestOptions>

  1. 与 IOptions<TestOptions> 的用法一样，区别就是依赖注入的生命周期为Scoped,所以没缓存，直接看代码：

    services.TryAdd(ServiceDescriptor.Scoped(typeof(IOptionsSnapshot<>), typeof(OptionsManager<>)));

  2. IOptionsSnapshot<TOptions> 比 IOptions<TOptions> 多了个方法TOptions Get(string name);

    Value属性其实就是调用了该方法，只是name为Options.DefaultName

  3. IOptionsSnapshot<TOptions> 继承了 IOptions<TOptions> (这里有个疑问，上面的OptionsManager<TOptions>继承了IOptions<TOptions>, IOptionsSnapshot<TOptions>2 个接口,也许是为了清晰吧)。

自定义配置文件(JSON)

有的时候配置信息很多，想在单独的文件中配置，ASP.NET Core 提供了INI、XML、JSON文件系统加载配置的方法。

  1. 首先在 Program.cs的CreateWebHostBuilder方法中添加如下代码：

    public static IWebHostBuilder CreateWebHostBuilder(string[] args)
 {
     return WebHost.CreateDefaultBuilder(args)
                 .ConfigureAppConfiguration((hostingContext, config) =>
                 {
                     //设置根目录,我们放在 /Config 文件夹下
                     // 此种写法不会加载  `appsettings.json`
                     // config.SetBasePath(Path.Combine(Directory.GetCurrentDirectory(), "Config"));
                     config.SetBasePath(Directory.GetCurrentDirectory());
                     //添加 setting.json 配置文件
                     //optional： 文件是否可选，当为false时 如果文件不存在 程序启动不起来
                     //reloadOnChange：文件改变后是否重新加载
                     config.AddJsonFile("Config/setting.json", optional: false, reloadOnChange: false);
                 })
                 .UseStartup<Startup>();
 }

    我们看下 reloadOnChange 参数处理了哪些事情：

    if (Source.ReloadOnChange && Source.FileProvider != null)
{
    ChangeToken.OnChange(
        //监视文件 如果改变就执行 Load(true) 方法
        () => Source.FileProvider.Watch(Source.Path),
        () => {
            Thread.Sleep(Source.ReloadDelay);
            Load(reload: true);
        });
}
  2. 创建setting.json： 
    {
        "Rookie": {
            "Name": "DDD",
            "Age": 12,
            "Sex": "男"
        }
}
  3. 在 Controller 中： 
     [Route("api/[controller]")]
 [ApiController]
 public class OptionsController : ControllerBase
 {
     private readonly IConfiguration _configuration;
     public OptionsController(IConfiguration configuration)
     {
         _configuration = configuration;
     }
     [HttpGet]
     public string Index()
     {
         return JsonConvert.SerializeObject(new
         {
             Name = _configuration["Rookie:Name"],
             Age = _configuration["Rookie:Age"],
             Sex = _configuration["Rookie:Sex"]
         });
     }
 }

自定义配置文件(JSON)绑定到对象

通过上面配置发现获取配置用的是 _configuration["Name"] 方式，下面我们绑定到对象上

  1. 定义配置对象 Setting 类
  2. 在Startup.cs的ConfigureServices方法添加代码：

    services.Configure<Setting>(Configuration.GetSection("Rookie"));

    GetSection方法:获得指定键的配置子部分

  3. 用法和上面一样

不知道发现个情况没，我们setting.json的配置文件的信息也是存到_configuration中的，如果文件多了很可能会覆盖节点，下面我们换一种写法。

  1. 首先删除 Program.cs中CreateWebHostBuilder方法的代码：

    config.AddJsonFile("Config/setting.json", optional: false, reloadOnChange: true);

  2. 修改配置文件setting.json： 
    {
   "Name": "DDD",
   "Age": 12,
   "Sex": "男"
}
  3. 在中Startup.cs的ConfigureServices方法中添加： 
    var config = new ConfigurationBuilder()
             .SetBasePath(Directory.GetCurrentDirectory())
             .AddJsonFile("Config/setting.json", optional: false, reloadOnChange: true)
             .Build();
 services.Configure<Setting>(config);

这样就不会影响 全局 的配置信息了

其他方式

  1. 我们看下下面 2 个方式：

    [Route("[controller]")]
[ApiController]
public class HomeController : ControllerBase
{
    private readonly IConfiguration _configuration;
    private readonly TestOptions _bindOptions = new TestOptions();
    private readonly Parent _parent = new Parent();

    public HomeController(IConfiguration configuration)
    {
        //全部绑定
        _configuration.Bind(_bindOptions);
        //部分绑定
        _configuration.GetSection("Parent").Bind(_parent);
    }

    [HttpGet("options")]
    public string Options()
    {
        return JsonConvert.SerializeObject(new
        {
            BindOptions = _bindOptions,
            Parent = _parent
        });
    }
}

    个人感觉这种方式有点多余 ( ╯□╰ )

  2. IOptionsMonitor、IOptionsFactory、IOptionsMonitorCache 方式：

    我们看如下代码

    services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptions<>), typeof(OptionsManager<>)));
services.TryAdd(ServiceDescriptor.Scoped(typeof(IOptionsSnapshot<>), typeof(OptionsManager<>)));
services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitor<>), typeof(OptionsMonitor<>)));
services.TryAdd(ServiceDescriptor.Transient(typeof(IOptionsFactory<>), typeof(OptionsFactory<>)));
services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitorCache<>), typeof(OptionsCache<>)));

    这里只说下 IOptionsMonitor<>:

     [Route("[controller]")]
 [ApiController]
 public class HomeController : ControllerBase
 {
     private readonly IOptionsMonitor<TestOptions> _optionsMonitor;

     public HomeController(IOptionsMonitor<TestOptions> optionsMonitor
     , ILogger<HomeController> logger)
     {
         _optionsMonitor = optionsMonitor;
         _logger = logger;
     }

     [HttpGet("options")]
     public string Options()
     {
         //这里有个变更委托
         _optionsMonitor.OnChange((options, name) =>
         {
             var info = JsonConvert.SerializeObject(new
             {
                 Options = options,
                 Name = name
             });
             _logger.LogInformation($"配置信息已更改：{info}");
         });
         return JsonConvert.SerializeObject(new
         {
             OptionsMoitor = _optionsMonitor
         });
     }

    当我们修改配置文件后会看到日志信息：

    info: WebApiSample.Controllers.HomeController[0]

    配置信息已更改：{"Options":{"ConnectionString":"data source=.;initial catalog=TEST;user id=sa","Parent":{"Child1":"child","Child2":{"GrandChildren":"grandchildren"}}},"Name":"TestOptions"}

    info: WebApiSample.Controllers.HomeController[0]

    配置信息已更改：{"Options":{"ConnectionString":"data source=.;initial catalog=TEST;user id=sa","Parent":{"Child1":"child","Child2":{"GrandChildren":"grandchildren"}}},"Name":"TestOptions"}

    info: WebApiSample.Controllers.HomeController[0]

    配置信息已更改：{"Options":{"ConnectionString":"data source=.;initial catalog=TEST;user id=sa","Parent":{"Child1":"child","Child2":{"GrandChildren":"grandchildren"}}},"Name":"TestOptions"}

    info: WebApiSample.Controllers.HomeController[0]

    配置信息已更改：{"Options":{"ConnectionString":"data source=.;initial catalog=TEST;user id=sa","Parent":{"Child1":"child","Child2":{"GrandChildren":"grandchildren"}}},"Name":"TestOptions"}

    不知道为什么会有这么多日志...

    还有一点不管我们修改哪个日志文件，只要是执行了AddJsonFile的文件，都会触发该事件

写在最后

写的有点乱希望不要见怪，本以为一个配置模块应该不会复杂，但看了源代码后发现里面的东西好多...

本来还想写下是如何实现的，但感觉太长了就算了。

最后还是希望大家以批判的角度来看，有任何问题可在留言区留言！

原文地址：https://www.cnblogs.com/dudd/p/9700927.html

时间： 2024-11-07 13:23:58

ASP.NET Core 中的配置的相关文章

在Asp.Net Core中关于appsettings.json的快速简便的读取和设置方式

在Asp.Net Core 中,配置信息已从原来Asp.Net的XML格式改为了更为流行的JSON格式,配置文件也由原来的App.config改成了appsettings.json. 那么对于这个appsettings.json中的配置信息的读取,使用最多的是使用与配置对应的实体模型,调用services.Configure<TOptions>()泛型方法载入配置. 这种方式的好处在于,将配置数据载入到对应的实体中后,项目的其它地方都可以使用,常见的是用于Controller中. 其缺点是不快

浅析 .Net Core中Json配置的自动更新

Pre 很早在看 Jesse 的Asp.net Core快速入门的课程的时候就了解到了在Asp .net core中,如果添加的Json配置被更改了,是支持自动重载配置的,作为一名有着严重"造轮子"情节的程序员,最近在折腾一个博客系统,也想造出一个这样能自动更新以Mysql为数据源的ConfigureSource,于是点开了AddJsonFile这个拓展函数的源码,发现别有洞天,蛮有意思,本篇文章就简单地聊一聊Json config的ReloadOnChange是如何实现的,在学习Re

ASP.NET Core 中文文档 第三章 原理（7）配置

小分享:我有几张阿里云优惠券,用券购买或者升级阿里云相应产品最多可以优惠五折!领券地址:https://promotion.aliyun.com/ntms/act/ambassador/sharetouser.html?userCode=ohmepe03 原文:Configuration 作者:Steve Smith.Daniel Roth 翻译:刘怡(AlexLEWIS) 校对:孟帅洋(书缘) ASP.NET Core 支持多种配置选项.应用程序配置数据内建支持读取 JSON.XML 和 IN

ASP.Net Core 中使用Zookeeper搭建分布式环境中的配置中心系列一：使用Zookeeper.Net组件演示基本的操作

前言:马上要过年了,祝大家新年快乐!在过年回家前分享一篇关于Zookeeper的文章,我们都知道现在微服务盛行,大数据.分布式系统中经常会使用到Zookeeper,它是微服务.分布式系统中必不可少的分布式协调框架.它的作用体现在分布式系统中解决了配置中心的问题,以及解决了在分布式环境中不同进程之间争夺资源的问题,也就是分布式锁的功能以及分布式消息队列功能等等.所以在微服务的环境中Zookeeper是现在很多公司首选的分布式协调框架,包括我之前的公司也在使用Zookeeper.说了这么多,没别的就

如何在ASP.NET Core中应用Entity Framework

注:本文提到的代码示例下载地址> How to using Entity Framework DB first in ASP.NET Core 如何在ASP.NET Core中应用Entity Framework 首先为大家提醒一点,.NET Core和经典.NET Framework的Library是不通用的,包括Entity Framework! 哪怎么办? 别急,微软为.NET Core发布了.NET Core版本的Entity Framework,具体配置方法与经典.NET Framew

如何在ASP.NET Core中实现一个基础的身份认证

注:本文提到的代码示例下载地址> How to achieve a basic authorization in ASP.NET Core 如何在ASP.NET Core中实现一个基础的身份认证 ASP.NET终于可以跨平台了,但是不是我们常用的ASP.NET, 而是叫一个ASP.NET Core的新平台,他可以跨Windows, Linux, OS X等平台来部署你的web应用程序,你可以理解为,这个框架就是ASP.NET的下一个版本,相对于传统ASP.NET程序,它还是有一些不同的地方的,比

ASP.NET Core中使用xUnit进行单元测试

单元测试的功能自从MVC的第一个版本诞生的时候,就是作为一个重要的卖点来介绍的,通常在拿MVC与webform比较的时候,单元测试就是必杀底牌,把webform碾压得一无是处. 单元测试的重要性不用多说了,有单元测试的做兜底的项目,好比给开发人员买了份保险,当然这个保险的质量取决于单元测试的质量,那些一路Mock的单元测试,看起来很美,但是什么都cover不到.目前工作中的一个老项目,有2万多个单元测试用例,其中不少是用心之作,真正落实到了业务逻辑,开发人员可以放心的去修改代码,当然一切都必须按

NLog在asp.net core中的应用

Asp.net core中,自带的Log是在当selfhost运行时,在控制台中输出,不便于查阅,如果用一个log架框,把日志持久化,便于查询． NLog是一个免费的日志记录框架,专门为.net平台下的框架提供日志功能,本文主要说明asp.net core下怎么使用NLog. 首先用Nuget安装NLog.Extensions.Logging和NLog.Web.AspNetCore两个类库. 修改project.json,在publishOptions中添加"nlog.config节点"

在Asp.Net Core中添加区域的简单实现

使用区域,可以有效的对业务进行隔离,各种业务及分工可以更灵活.在Asp.Net Core中启用区域也是极简单的. 使用步骤: 1.在 Startup.cs 中添加区域的路由: app.UseMvc(routes => { routes.MapRoute( name: "area", template: "{area:exists}/{controller=Home}/{action=Index}/{id?}"); routes.MapRoute( name: