.NET Core - .NET Core | 读取配置文件 - 《.Net 学习历程》

一、前言">一、前言
二、读取配置文件">二、读取配置文件
- 1、Json配置文件说明">1、Json配置文件说明
  - 1. 配置文件">1. 配置文件
  - 2. json配置文件示例">2. json配置文件示例
- 2、读取配置文件的几种方式">2、读取配置文件的几种方式
三、公用类的封装">三、公用类的封装
- 1、获取配置信息设置为全局变量
  - 1. 声明一个静态类Common.cs
  - 2. 使用
- 2、Json转类封装

一、前言

在项目开发过程中，不可避免的会设置一些全局的可变的参数，如连接字符串、功能开关、Swagger配置、Redis配置等等。 .NET Core 将这些配置参数统一放在 appsettings.json 文件中进行管理，并提供了 IConfiguration 接口，在需要读取配置文件内容的类中，注入 IConfiguration 即可。但是，.NET Core 默认是通过构造函数注入，而 appsettings.json 的内容是不会经常进行变动，如果每个需要获取配置值类，都先在构造函数注入 IConfiguration 才能使用，也挺烦的。所以本篇文章介绍多种获取配置文件的方法。后面也会展示如何写一个公用类，对配置的读取进行简单的封装。

二、读取配置文件

1、Json配置文件说明

1. 配置文件

.NET Core | 读取配置文件 - 图1

配置文件指的是appsettings.json，不是 launchSettings.json，不要把json内容放错地方了。

2. json配置文件示例

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        }
    },
    "Setting": {
        "Url": "http://localhost:8080/",
        "Name": "localhost"
    }
}

2、读取配置文件的几种方式

1. 通过依赖注入直接读取

通过依赖注入的方式

[ApiController]
[Route("[controller]/[action]")]
public class TestController: ControllerBase
{
    public IConfiguration _configuration { get; set; }
    public TestController(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    /// <summary>
    /// 方式一：直接读取单个值
    /// </summary>
    [HttpGet, HttpPost]
    public void GetConfigDemo1()
    {
        var url = _configuration["Setting:Url"]; // http://localhost:8080/
        var url2 = _configuration.GetValue<string>("Setting:Url"); // http://localhost:8080/
        var url3 = _configuration.GetSection("Setting").GetSection("Url").Value; // http://localhost:8080/
    }
}

2. 读取Json对象

如果想把json对象拿去使用的话，一般都是转成类去使用，毕竟对于类在熟悉不过了，方便又熟练 1）新建Json模块Setting类

/// <summary>
/// Json模块Setting类
/// </summary>
public class SettingClass
{
    /// <summary>
    /// 地址
    /// </summary>
    public string Url { get; set; }
    /// <summary>
    /// 名称
    /// </summary>
    public string Name { get; set; }
}

2）新建应用设置类AppSettings

/// <summary>
/// 应用设置类
/// 总类：对应json文件，确定json模块与对象
/// 这里负责一一绑定json模块与对象
/// </summary>
public static class AppSettings
{
    public static SettingClass settingClass { get; set; }
    public static void Init(IConfiguration configuration)
    {
        // 将Setting模块绑定到Json模块的Setting类
        settingClass = new SettingClass();
        configuration.Bind("Setting", settingClass);
    }
}

3）在Startup.cs中调用AppSettings的初始化方法

.NET Core | 读取配置文件 - 图2

// AppSettings总类进行调用静态方法
AppSettings.Init(Configuration);

4）在控制器中使用(静态类静态变量)

[ApiController]
[Route("[controller]/[action]")]
public class TestController: ControllerBase
{
    public IConfiguration _configuration { get; set; }
    public TestController(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    /// <summary>
    /// 方式二：读取Json对象 - 变成类使用
    /// </summary>
    [HttpGet, HttpPost]
    public void GetConfigDemo2()
    {
        var url = AppSettings.settingClass.Url; // http://localhost:8080/
        var name = AppSettings.settingClass.Name; // localhost
    }
}

3. 在注册服务中绑定实体类与Json文件，使用时声明为全局常量

1）在Startup.cs中将Json模块类与Json文件对应内容绑定（Json模块类如方式2的SettingClass类）

.NET Core | 读取配置文件 - 图3

将注册服务的时候把配置文件与类绑定好值，然后在使用的时候去用

services.Configure<SettingClass> (option =>
{
    option.Url = Configuration["Setting:Url"];
    option.Name = Configuration["Setting:Name"];
});

2）在控制器中使用在用的地方IOptions

[ApiController]
[Route("[controller]/[action]")]
public class TestController: ControllerBase
{
    public IConfiguration _configuration { get; set; }
    public string UrlStr { get; set; }
    public string NameStr { get; set; }
    public TestController(IConfiguration configuration, IOptions<SettingClass> settings)
    {
        _configuration = configuration;
        UrlStr = settings.Value.Url;
        NameStr = settings.Value.Name;
    }
    /// <summary>
    /// 方法三：在注册服务的时候把配置文件与类绑定好值，使用时声明为全局常量
    /// </summary>
    [HttpGet, HttpPost]
    public void GetConfigDemo3()
    {
        var url = UrlStr; // http://localhost:8080/
        var name = NameStr; // localhost
    }
}

更多方式请看一下文章：

三、公用类的封装

1、获取配置信息设置为全局变量

1. 声明一个静态类Common.cs

using System;
using System.IO;
using Microsoft.Extensions.Configuration;
namespace test
{
    public static class Common
    {
        public static string CommonUrl;
        static Common()
        {
            var builder = new ConfigurationBuilder()
               .SetBasePath(Directory.GetCurrentDirectory())
               .AddJsonFile("appsettings.json");
            var config = builder.Build();
            var commonurl =  config["CommonUrl"];
            CommonUrl = commonurl;
        }
    }
}

2. 使用

Common.CommonUrl;

2、Json转类封装

1. 新建公共类：AppSettings.cs

新建文件夹 Helper 文件夹，帮助类都放此文件夹中。添加类 AppSettings.cs

using Microsoft.Extensions.Configuration;
namespace AMO.Core.Helper
{
    /// <summary>
    /// 读取配置文件帮助类
    /// </summary>
    public class AppSettings
    {
        #region 注入参数
        /// <summary>
        /// 配置文件
        /// </summary>
        private static IConfiguration? _config;
        #endregion
        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="configuration">配置文件</param>
        public AppSettings()
        {
            _config = new ConfigurationBuilder()
                    .AddJsonFile("appsettings.json", true, reloadOnChange: true)
                    .Build();
        }
        #endregion
        #region 静态方法
        /// <summary>
        /// 读取指定节点信息
        /// </summary>
        /// <param name="sessions">节点名称</param>
        /// <returns></returns>
        public static string ReadString(params string[] sessions)
        {
            try
            {
                if (_config != null && sessions.Any())
                {
                    string? str = _config[string.Join(":", sessions)];
                    if (!string.IsNullOrEmpty(str))
                    {
                        return str;
                    }
                }
            }
            catch
            {
                return string.Empty;
            }
            return string.Empty;
        }
        /// <summary>
        /// 读取实体信息
        /// </summary>
        /// <param name="sessions">节点名称</param>
        /// <returns></returns>
        public static T ReadObject<T>(params string[] sessions) where T : class, new()
        {
            T data = new();
            try
            {
                if (_config != null && sessions.Any())
                {
                    _config.Bind(string.Join(":", sessions), data);
                }
            }
            catch
            {
                return data;
            }
            return data;
        }
        /// <summary>
        /// 读取实体数组信息
        /// </summary>
        /// <param name="sessions">节点名称</param>
        /// <returns></returns>
        public static List<T> ReadList<T>(params string[] sessions) where T : class
        {
            List<T> list = new();
            try
            {
                if (_config != null && sessions.Any())
                {
                    _config.Bind(string.Join(":", sessions), list);
                }
            }
            catch
            {
                return list;
            }
            return list;
        }
        #endregion
    }
}

2. 注册服务

public static void Run(this WebApplicationBuilder builder)
{
    var logger = NLog.LogManager.Setup().GetCurrentClassLogger();
    logger.Debug("[启动服务]");
    try
    {
        // 配置文件，放在第一句，并注册为Singleton
        builder.Services.AddSingleton(new AppSettings());
        // ... 其他
    }
}

3. 使用

修改 appsettings.json 添加测试配置

  /* 单值 */
  "FileLoad": "/nginx/fileload",
  /* 对象 */
  "Redis": {
    "Enabled": true,
    "ConnectionString": "127.0.0.1:6379,ssl=false,abortConnect=false,connectTimeout=5000",
    "DatabaseId": 10
  }

定义 Redis 配置类, 类中属性记得给默认值，避免在使用的时候出现 null 的情况。

public class RedisConfig
{
    public bool Enabled { get; set; } = false;
    public string ConnectionString { get; set; } = "127.0.0.1:6379,ssl=false,abortConnect=false,connectTimeout=5000";
    public int DatabaseId { get; set; } = 10;
}

Controller 写测试接口

[HttpGet("read-string")]
public string ReadString(string key)
{
    string data = AppSettings.ReadString(key);
    return data;
}
[HttpGet("read-object")]
public RedisConfig ReadObject(string key)
{
    RedisConfig data = AppSettings.ReadObject<RedisConfig>(key);
    return data;
}

测试结果：

获取对象
[Request URL] http://localhost:5118/WeatherForecast/read-object?key=Redis
[Server response]
{
  "enabled": true,
  "connectionString": "127.0.0.1:6379,ssl=false,abortConnect=false,connectTimeout=5000",
  "databaseId": 10
}
获取单值
[Request URL] http://localhost:5118/WeatherForecast/read-string?key=FileLoad
[Server response] /nginx/fileload

以上，对 appsettings.json 进行了简单封装。你可以在任何需要获取配置的类中使用 AppSettings。