DockerBuild/DockerStudyApi/Controllers/DemoController.cs

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading.Tasks;

namespace DockerStudyApi.Controllers
{
    /// <summary>
    /// 配置测试控制器
    /// </summary>
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class DemoController : ControllerBase
    {
        private readonly ILogger<DemoController> _logger;
        private readonly IOptions<TestOption> _tespOption;
        private readonly IOptionsMonitor<TestOption> _monitorTestOption;
        private readonly IOptionsMonitorCache<TestOption> _monitorCacheTestOption;
        private readonly IOptionsSnapshot<TestOption> _snapshotTestOption;

        private readonly IConfiguration _configuration;

        public DemoController
        (
            ILogger<DemoController> logger,
            IOptions<TestOption> tespOption,
            IOptionsMonitor<TestOption> monitorTestOption,
            IOptionsMonitorCache<TestOption> monitorCacheTestOption,
            IOptionsSnapshot<TestOption> snapshotTestOption, 
            IConfiguration configuration
        )
        {
            _logger = logger;
            _tespOption = tespOption;
            _monitorTestOption = monitorTestOption;
            _monitorCacheTestOption = monitorCacheTestOption;
            _snapshotTestOption = snapshotTestOption;

            _configuration = configuration; 
        }

        /// <summary>
        /// 服务测试
        /// </summary>
        [HttpGet]
        public IActionResult Ping()
        {
            return Ok();
        }

        /// <summary>
        /// 获取运行时信息
        /// </summary>
        [HttpGet]
        public IActionResult RunTime()
        {
            var runInfo = new Dictionary<string, string>()
            {
                {"操作系统",RuntimeInformation.OSDescription },
                {".Net版本",RuntimeInformation.FrameworkDescription },
                {"运行平台",RuntimeInformation.RuntimeIdentifier },
                {"平台架构",RuntimeInformation.OSArchitecture.ToString() },
                {"进程架构",RuntimeInformation.ProcessArchitecture.ToString() },
            };

            return Ok(runInfo);
        }

        /// <summary>
        /// 说明：泛型左右尖括号，不能写在注释里，会生成无效的xml
        /// 解决：用[]或{}或中文符号＜＞ 代替，或者使用xml转义字符 &lt;&gt;
        /// 获取 IOptions＜TestOption＞
        /// </summary>
        [HttpGet]
        public TestOption TestOption()
        {
            return _tespOption.Value;
        }

        /// <summary>
        /// 获取 IOptionsMonitor＜TestOptionT＞
        /// </summary>
        [HttpGet]
        public TestOption MonitorTestOption()
        {
            _monitorTestOption.OnChange(_ => _logger.LogWarning(_monitorTestOption.CurrentValue.AppId));

            return _monitorTestOption.CurrentValue;
        }

        /// <summary>
        /// 获取 IOptionsMonitorCache＜TestOption＞
        /// </summary>
        [HttpGet]
        public TestOption MonitorCacheTestOption()
        {
            return _monitorCacheTestOption.GetOrAdd("demo",()=> new TestOption());
        }

        /// <summary>
        /// 获取 IOptionsSnapshot＜TestOption＞
        /// </summary>
        [HttpGet]
        public TestOption SnapshotTestOption()
        {
            return _snapshotTestOption.Value;
        }

        /// <summary>
        /// 获取命令参数
        /// (仅支持字符串或Key=value两种形式)
        /// </summary>
        [HttpGet]
        public IActionResult CmdPara([Required(ErrorMessage = "命令行参数名必填")]string cmdName)
        {
            var cmdArgs = System.Environment.GetCommandLineArgs();
            if (cmdArgs == null)
            { 
                return Ok("启动时没有设置：命令行参数");
            }

            var kvArgs = new Dictionary<string,string>();
            var singleArgs=  new List<string>();

            foreach (var arg in cmdArgs)
            {
                var item = arg.Split('=').ToList();
                if (item.Count ==1)
                {
                    singleArgs.Add(item[0]);
                }

                if (item.Count == 2)
                { 
                    kvArgs.Add(item[0], item[1]); 
                }

            }

            var result =string.Empty;

            var kvArg = kvArgs.FirstOrDefault(q=>q.Key == cmdName);

            if (kvArg.Key == cmdName)
            {
                result = kvArg.Value;

                return Ok($"{cmdName} 命令参数值为:{kvArg.Value} ");
            }

            var singleArg = singleArgs.FirstOrDefault(q=> q == cmdName);
            return Ok(singleArg ?? $"无 {cmdName} 命令参数 ");
           
        }

        /// <summary>
        /// 获取所有命令参数
        /// </summary>
        [HttpGet]
        public IActionResult AllCmdPara()
        {
            var cmdArgs = System.Environment.GetCommandLineArgs();
            if (cmdArgs == null)
            {
                return Ok("启动时没有设置：命令行参数");
            }
            return Ok(cmdArgs);

        }

        /// <summary>
        /// 获取环境变量
        /// </summary>
        [HttpGet]
        public IActionResult Evn([Required(ErrorMessage = "环境变量名必填")]string envName)
        {
            var envValue = System.Environment.GetEnvironmentVariable(envName);
            return Ok(envValue??"无此环境变量");
        }

        /// <summary>
        /// 获取AspNetCore环境变量
        /// (以ASPNETCORE_开头)
        /// </summary>
        [HttpGet]
        public IActionResult AspNetCoeEvn()
        {
            var envValues = System.Environment.GetEnvironmentVariables();
            if (envValues == null)
            { 
                return Ok("无环境变量！");
            }

            var keys = envValues.Keys.Cast<string>().ToList();
            foreach (var key in keys)
            {
                if (string.IsNullOrEmpty(key))
                {
                    continue;
                }
                if (key.ToString().ToUpper().StartsWith("ASPNETCORE_") == false)
                {
                    envValues.Remove(key);
                }
            }
            return Ok(envValues);
        }

        /// <summary>
        /// 获取所有环境变量
        /// </summary>
        [HttpGet]
        public IActionResult AllEvn()
        {
            var envValues = System.Environment.GetEnvironmentVariables();
            return Ok(envValues);
        }

        /// <summary>
        /// 获取配置项
        /// </summary>
        [HttpGet]
        public IActionResult ConfigItem([Required(ErrorMessage = "配置项名称必填")]string itemName)
        {
            var envValue = _configuration.GetValue<string>(itemName);
            return Ok(envValue ?? "无此配置变量");
        }

        /// <summary>
        /// 获取所有配置项
        /// </summary>
        [HttpGet]
        public IActionResult AllConfigItes()
        {
            return Ok(_configuration.GetChildren());
        }

        /// <summary>
        /// 获取配置源
        /// </summary>
        [HttpGet]
        public IActionResult ConfigProviders()
        {
            var root = _configuration as ConfigurationRoot;

            var providers = root.Providers.Select(p=>new { 
                Name=p.GetType().FullName,
            });

            return Ok(providers);
        }
    }
}