【问题标题】:Getting value from appsettings.json in .net core从 .net 核心中的 appsettings.json 获取价值
【发布时间】:2018-04-07 00:47:09
【问题描述】:

不确定我在这里遗漏了什么,但我无法从我的 .net 核心应用程序中的 appsettings.json 获取值。我的 appsettings.json 为:

{
    "AppSettings": {
        "Version": "One"
    }
}

启动:

public class Startup
{
    private IConfigurationRoot _configuration;
    public Startup(IHostingEnvironment env)
    {
        _configuration = new ConfigurationBuilder()
    }
    public void ConfigureServices(IServiceCollection services)
    {
      //Here I setup to read appsettings        
      services.Configure<AppSettings>(_configuration.GetSection("AppSettings"));
    }
}

型号:

public class AppSettings
{
    public string Version{ get; set; }
}

控制器:

public class HomeController : Controller
{
    private readonly AppSettings _mySettings;

    public HomeController(IOptions<AppSettings> settings)
    {
        //This is always null
        _mySettings = settings.Value;
    }
}

_mySettings 始终为空。我在这里有什么遗漏吗?

【问题讨论】:

  • read the documentation了解如何使用配置。您在启动类中设置的配置不正确。
  • 这甚至可以通过使用 IConfiguration 的依赖注入来简化。这里解释coding-issues.com/2018/10/…
  • 这个问题有这么多截然不同的答案这一事实凸显了这个问题。几乎让我想知道是否更容易读取设置文件并反序列化为使用在线 json -> c# 类生成器创建的对象。拥有非强类型的设置对我来说似乎很原始。

标签: c# asp.net-core configuration asp.net-core-mvc appsettings


【解决方案1】:

程序和启动类

.NET Core 2.x

您不需要在Startup 构造函数中新建IConfiguration。它的实现将由 DI 系统注入。

// Program.cs
public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .Build();            
}

// Startup.cs
public class Startup
{
    public IHostingEnvironment HostingEnvironment { get; private set; }
    public IConfiguration Configuration { get; private set; }

    public Startup(IConfiguration configuration, IHostingEnvironment env)
    {
        this.HostingEnvironment = env;
        this.Configuration = configuration;
    }
}

.NET Core 1.x

您需要告诉Startup 加载appsettings 文件。

// Program.cs
public class Program
{
    public static void Main(string[] args)
    {
        var host = new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .UseApplicationInsights()
            .Build();

        host.Run();
    }
}

//Startup.cs
public class Startup
{
    public IConfigurationRoot Configuration { get; private set; }

    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
            .AddEnvironmentVariables();

        this.Configuration = builder.Build();
    }
    ...
}

获取价值

您可以通过多种方式获取从应用设置中配置的值:

  • 使用ConfigurationBuilder.GetValue&lt;T&gt;的简单方法
  • 使用 Options Pattern

假设您的appsettings.json 如下所示:

{
    "ConnectionStrings": {
        ...
    },
    "AppIdentitySettings": {
        "User": {
            "RequireUniqueEmail": true
        },
        "Password": {
            "RequiredLength": 6,
            "RequireLowercase": true,
            "RequireUppercase": true,
            "RequireDigit": true,
            "RequireNonAlphanumeric": true
        },
        "Lockout": {
            "AllowedForNewUsers": true,
            "DefaultLockoutTimeSpanInMins": 30,
            "MaxFailedAccessAttempts": 5
        }
    },
    "Recaptcha": { 
        ...
    },
    ...
}

简单方法

您可以将整个配置注入您的控制器/类的构造函数(通过IConfiguration)并使用指定的键获取您想要的值:

public class AccountController : Controller
{
    private readonly IConfiguration _config;

    public AccountController(IConfiguration config)
    {
        _config = config;
    }

    [AllowAnonymous]
    public IActionResult ResetPassword(int userId, string code)
    {
        var vm = new ResetPasswordViewModel
        {
            PasswordRequiredLength = _config.GetValue<int>(
                "AppIdentitySettings:Password:RequiredLength"),
            RequireUppercase = _config.GetValue<bool>(
                "AppIdentitySettings:Password:RequireUppercase")
        };

        return View(vm);
    }
}

选项模式

如果您只需要应用设置中的一两个值,ConfigurationBuilder.GetValue&lt;T&gt; 就非常有用。但是,如果您想从应用设置中获取多个值,或者您不想在多个位置对这些键字符串进行硬编码,那么使用 Options Pattern 可能会更容易。选项模式使用类来表示层次/结构。

使用选项模式:

  1. 定义类来表示结构
  2. 注册这些类绑定的配置实例
  3. IOptions&lt;T&gt; 注入到要获取值的控制器/类的构造函数中

1。定义配置类来表示结构

您可以定义具有需要完全匹配应用设置中的键的属性的类。类的名称不必与应用设置中的部分名称匹配:

public class AppIdentitySettings
{
    public UserSettings User { get; set; }
    public PasswordSettings Password { get; set; }
    public LockoutSettings Lockout { get; set; }
}

public class UserSettings
{
    public bool RequireUniqueEmail { get; set; }
}

public class PasswordSettings
{
    public int RequiredLength { get; set; }
    public bool RequireLowercase { get; set; }
    public bool RequireUppercase { get; set; }
    public bool RequireDigit { get; set; }
    public bool RequireNonAlphanumeric { get; set; }
}

public class LockoutSettings
{
    public bool AllowedForNewUsers { get; set; }
    public int DefaultLockoutTimeSpanInMins { get; set; }
    public int MaxFailedAccessAttempts { get; set; }
}

2。注册配置实例

然后你需要在启动时在ConfigureServices()注册这个配置实例:

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
...

namespace DL.SO.UI.Web
{
    public class Startup
    {
        ...
        public void ConfigureServices(IServiceCollection services)
        {
            ...
            var identitySettingsSection = 
                _configuration.GetSection("AppIdentitySettings");
            services.Configure<AppIdentitySettings>(identitySettingsSection);
            ...
        }
        ...
    }
}

3。注入 IOptions

最后在要获取值的控制器/类上,需要通过构造函数注入IOptions&lt;AppIdentitySettings&gt;

public class AccountController : Controller
{
    private readonly AppIdentitySettings _appIdentitySettings;

    public AccountController(IOptions<AppIdentitySettings> appIdentitySettingsAccessor)
    {
        _appIdentitySettings = appIdentitySettingsAccessor.Value;
    }

    [AllowAnonymous]
    public IActionResult ResetPassword(int userId, string code)
    {
        var vm = new ResetPasswordViewModel
        {
            PasswordRequiredLength = _appIdentitySettings.Password.RequiredLength,
            RequireUppercase = _appIdentitySettings.Password.RequireUppercase
        };

        return View(vm);
    }
}

【讨论】:

  • 你能像sn-p一样简单吗?
  • 从全栈 .net 倒退是多么可怕的一步
  • 好的,所以对于 .NET Core 3,您需要 Microsoft.Extensions.Options.ConfigurationExtensions 包,它工作正常
  • 我们需要这么多解释才能访问一个简单的应用程序设置,这太荒谬了……这曾经是 .NET Framework 中的一行。我知道依赖注入通常是一件好事,但在这种情况下,它是麻烦而不是帮助。这一次,感觉就像 C# 正在考虑代码,而不是开发人员 - 这一切都有点 Java
  • 未来自我注意:GetValue&lt;T&gt; 方法在 Microsoft.Extensions.Configuration.Binder Nuget 包中
【解决方案2】:

只需创建一个 AnyName.cs 文件并粘贴以下代码。

using System;
using System.IO;
using Microsoft.Extensions.Configuration;

namespace Custom
{
    static class ConfigurationManager
    {
        public static IConfiguration AppSetting { get; }
        static ConfigurationManager()
        {
            AppSetting = new ConfigurationBuilder()
                    .SetBasePath(Directory.GetCurrentDirectory())
                    .AddJsonFile("YouAppSettingFile.json")
                    .Build();
        }
    }
}

必须将 YouAppSettingFile.json 文件名替换为您的文件名。
您的 .json 文件应如下所示。

{
    "GrandParent_Key" : {
        "Parent_Key" : {
            "Child_Key" : "value1"
        }
    },
    "Parent_Key" : {
        "Child_Key" : "value2"
    },
    "Child_Key" : "value3"
}

现在您可以使用它了。
不要忘记在您要使用的类中添加参考

using Custom;

检索值的代码。

string value1 = ConfigurationManager.AppSetting["GrandParent_Key:Parent_Key:Child_Key"];
string value2 = ConfigurationManager.AppSetting["Parent_Key:Child_Key"];
string value3 = ConfigurationManager.AppSetting["Child_Key"];

【讨论】:

  • 不要在生产中使用它。这种方法是导致我们的 web api 内存泄漏的原因。如果您使用的是 netcore,则可以在任何地方注入 IConfiguration,只需查看上述答案即可。
  • 我不建议到处注入IConfiguration,因为这可能会导致一些安全问题;相反,您可以做的是从该配置中创建一些您需要的抽象层,并在您需要的地方使用它们。通过这种方式,您的代码更加安全,并且您的代码将不依赖于 IConfiguration 或任何实现。
  • 找不到我的ConfigurationBuilder。我正在使用 .NET Core 3.1
【解决方案3】:

添加到 David Liang 对 Core 2.0 的回答 -

appsettings.json 文件链接到ASPNETCORE_ENVIRONMENT 变量。

ASPNETCORE_ENVIRONMENT 可以设置为任何值,但框架支持三个值:DevelopmentStagingProduction。如果未设置ASPNETCORE_ENVIRONMENT,则默认为Production

对于这三个值,这些 appsettings.ASPNETCORE_ENVIRONMENT.json 文件支持开箱即用 - appsettings.Staging.jsonappsettings.Development.jsonappsettings.Production.json

以上三个应用设置json文件可以用来配置多个环境。

示例 - appsettings.Staging.json

{
    "Logging": {
        "IncludeScopes": false,
        "LogLevel": {
            "System": "Information",
            "Microsoft": "Information"
        }
    },
    "MyConfig": "My Config Value for staging."
}

使用 Configuration["config_var"] 检索任何配置值。

public class Startup
{
    public Startup(IHostingEnvironment env, IConfiguration config)
    {
        Environment = env;
        Configuration = config;
        var myconfig = Configuration["MyConfig"];
    }

    public IConfiguration Configuration { get; }
    public IHostingEnvironment Environment { get; }
}

【讨论】:

  • 嵌套对象呢?
  • 可以通过 Configuration["MyConfig:SomethingNested"] 获得嵌套对象
  • 从文件github.com/aspnet/AspNetCore/blob/master/src/DefaultBuilder/src/… 的第 167 行可以看出,ASP.NET Core 当前加载了appsettings.json + appsettings.{env.EnvironmentName}.json。所以说 ASP.NET Core 只加载 Development、Staging 和 Production appsettings.json 文件的说法目前是不正确的。
  • 我应该每次都设置Windows变量ASPNETCORE_ENVIRONMENT吗?在 .Net 4 中事情变得容易多了。这些 JSON 狂热分子确实把事情搞砸了
  • @Toolkit 可以全局设置环境变量。 docs.microsoft.com/en-us/aspnet/core/fundamentals/…
【解决方案4】:

我想最简单的方法是通过 DI。进入 Controller 的示例。

// StartUp.cs
public void ConfigureServices(IServiceCollection services)
{
    ...
    // for get appsettings from anywhere
    services.AddSingleton(Configuration);
}

public class ContactUsController : Controller
{
    readonly IConfiguration _configuration;

    public ContactUsController(
        IConfiguration configuration)
    {
        _configuration = configuration;

        // sample:
        var apiKey = _configuration.GetValue<string>("SendGrid:CAAO");
        ...
    }
}

【讨论】:

  • 阅读其他答案,这应该是最好的。
  • 我错过了services.AddSingleton(Configuration);,现在它可以工作了
【解决方案5】:

在 Startup 类的构造函数中,您可以使用注入的 IConfiguration 对象访问 appsettings.json 和许多其他设置:

Startup.cs 构造函数

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;

        //here you go
        var myvalue = Configuration["Grandfather:Father:Child"];

    }

public IConfiguration Configuration { get; }

内容 appsettings.json

  {
  "Grandfather": {
    "Father": {
      "Child": "myvalue"
    }
  }

【讨论】:

  • 帮助我的是 'Configuration["Grandfather:Father:Child"]' 语法。
  • 这是一个出色的答案,其结构、清晰和重点突出。良好的沟通
  • 假设我更改了json文件中的值,那么是否需要重启应用才能拉取最新值?
  • @variable 更改应用设置 json 文件将导致应用自动重启
【解决方案6】:
    public static void GetSection()
    {
        Configuration = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json")
            .Build();

        string BConfig = Configuration.GetSection("ConnectionStrings")["BConnection"];

    }

【讨论】:

  • 不完整的答案
  • 我不同意@CarlosABS,这是最好的答案:所有其他人——出于某种神秘的原因——假设您正在使用 DI 并依赖他们的答案。 THIS 然而,这是答案的本质,至少对我来说是这样的:)除此之外我不需要任何东西,所以其他答案似乎有些臃肿。
  • 虽然你需要 三个 该死的 NuGet 包才能工作,但应该添加它:Microsoft.Extensions.ConfigurationMicrosoft.Extensions.Configuration.FileExtensionsMicrosoft.Extensions.Configuration.Json。我在 .net Core 中得到了整个模块化的东西,但耶稣有时你真的需要为每一行代码提供另一个包......
【解决方案7】:

如果你不想使用依赖注入:

在 appsettings.json 中

  "MyValues": {
    "Value1": "Xyz"
  }

在 .cs 文件中:

static IConfiguration conf = (new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json").Build());
public static string myValue1= conf["MyValues:Value1"].ToString();

【讨论】:

  • 在 Dot net core 3.1 中运行良好
  • 正是我所需要的!
  • 谢谢,搞定了
  • 简单易行!
【解决方案8】:

.NET 核心 3.X

无需创建新模型并在 Startup.cs 中设置。

控制器 添加新包 - 使用 Microsoft.Extensions.Configuration;

public class HomeController : Controller
{
    private readonly IConfiguration _mySettings;

    public HomeController (IConfiguration mySettings)
    {
         _mySettings= mySettings;
    }
 
    //ex: you can get value on below function 
    public IEnumerable<string> Get()
    {
        var result = _config.GetValue<string>("AppSettings:Version"); // "One"
        return new string[] { result.ToString() };
    }
}

【讨论】:

  • 什么是_config?
【解决方案9】:

对于 ASP.NET Core 3.1,您可以按照本指南进行操作:

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1

当您创建一个新的 ASP.NET Core 3.1 项目时,您将在 Program.cs 中拥有以下配置行:

Host.CreateDefaultBuilder(args)

这会启用以下功能:

  1. ChainedConfigurationProvider:将现有的 IConfiguration 添加为 资源。默认配置情况下,添加主机 配置并将其设置为应用程序的第一个来源 配置。
  2. appsettings.json 使用 JSON 配置 提供者。
  3. appsettings.Environment.json 使用 JSON 配置 提供者。例如,appsettings.Production.json 和 appsettings.Development.json。
  4. 应用程序在 开发环境。
  5. 使用环境的环境变量 变量配置提供程序。
  6. 命令行参数使用 命令行配置提供程序。

这意味着您可以注入IConfiguration 并使用字符串键获取值,甚至是嵌套值。赞IConfiguration["Parent:Child"];

例子:

appsettings.json

{
  "ApplicationInsights":
    {
        "Instrumentationkey":"putrealikeyhere"
    }
}

WeatherForecast.cs

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;
    private readonly IConfiguration _configuration;

    public WeatherForecastController(ILogger<WeatherForecastController> logger, IConfiguration configuration)
    {
        _logger = logger;
        _configuration = configuration;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        var key = _configuration["ApplicationInsights:InstrumentationKey"];

        var rng = new Random();
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

【讨论】:

【解决方案10】:

在我的例子中,它就像在 Configuration 对象上使用 Bind() 方法一样简单。然后将对象作为单例添加到 DI 中。

var instructionSettings = new InstructionSettings();
Configuration.Bind("InstructionSettings", instructionSettings);
services.AddSingleton(typeof(IInstructionSettings), (serviceProvider) => instructionSettings);

Instruction 对象可以任意复杂。

{  
 "InstructionSettings": {
    "Header": "uat_TEST",
    "SVSCode": "FICA",
    "CallBackUrl": "https://UATEnviro.companyName.co.za/suite/webapi/receiveCallback",
    "Username": "s_integrat",
    "Password": "X@nkmail6",
    "Defaults": {
    "Language": "ENG",
    "ContactDetails":{
       "StreetNumber": "9",
       "StreetName": "Nano Drive",
       "City": "Johannesburg",
       "Suburb": "Sandton",
       "Province": "Gauteng",
       "PostCode": "2196",
       "Email": "ourDefaultEmail@companyName.co.za",
       "CellNumber": "0833 468 378",
       "HomeNumber": "0833 468 378",
      }
      "CountryOfBirth": "710"
    }
  }

【讨论】:

    【解决方案11】:

    从 Asp.net core 2.2 到更高版本,您可以编写如下代码:

    第 1 步。创建 AppSettings 类文件。

    此文件包含一些方法来帮助从 appsettings.json 文件中按键获取值。如下代码所示:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Threading.Tasks;
    
    namespace ReadConfig.Bsl
    {
      public class AppSettings
      {
          private static AppSettings _instance;
          private static readonly object ObjLocked = new object();
          private IConfiguration _configuration;
    
          protected AppSettings()
          {
          }
    
          public void SetConfiguration(IConfiguration configuration)
          {
              _configuration = configuration;
          }
    
          public static AppSettings Instance
          {
              get
              {
                  if (null == _instance)
                  {
                      lock (ObjLocked)
                      {
                          if (null == _instance)
                              _instance = new AppSettings();
                      }
                  }
                  return _instance;
              }
          }
    
          public string GetConnection(string key, string defaultValue = "")
          {
              try
              {
                  return _configuration.GetConnectionString(key);
              }
              catch
              {
                  return defaultValue;
              }
          }
    
          public T Get<T>(string key = null)
          {
              if (string.IsNullOrWhiteSpace(key))
                  return _configuration.Get<T>();
              else
                  return _configuration.GetSection(key).Get<T>();
          }
    
          public T Get<T>(string key, T defaultValue)
          {
              if (_configuration.GetSection(key) == null)
                  return defaultValue;
    
              if (string.IsNullOrWhiteSpace(key))
                  return _configuration.Get<T>();
              else
                  return _configuration.GetSection(key).Get<T>();
          }
    
          public static T GetObject<T>(string key = null)
          {
              if (string.IsNullOrWhiteSpace(key))
                  return Instance._configuration.Get<T>();
              else
              {
                  var section = Instance._configuration.GetSection(key);
                  return section.Get<T>();
              }
          }
    
          public static T GetObject<T>(string key, T defaultValue)
          {
              if (Instance._configuration.GetSection(key) == null)
                  return defaultValue;
    
              if (string.IsNullOrWhiteSpace(key))
                  return Instance._configuration.Get<T>();
              else
                  return Instance._configuration.GetSection(key).Get<T>();
          }
      }
    }
    

    步骤 2. AppSettings 对象的初始配置

    我们需要在应用启动时声明并加载appsettings.json文件,并加载AppSettings对象的配置信息。我们将在 Startup.cs 文件的构造函数中完成这项工作。 请注意线AppSettings.Instance.SetConfiguration(Configuration);

    public Startup(IHostingEnvironment evm)
    {
        var builder = new ConfigurationBuilder()
          .SetBasePath(evm.ContentRootPath)
          .AddJsonFile("appsettings.json", true, true)
          .AddJsonFile($"appsettings.{evm.EnvironmentName}.json", true)
          .AddEnvironmentVariables();
        Configuration = builder.Build(); // load all file config to Configuration property 
        AppSettings.Instance.SetConfiguration(Configuration);       
    }
    

    好的,现在我有一个 appsettings.json 文件,其中包含如下一些键:

    {
      "Logging": {
        "LogLevel": {
          "Default": "Information",
          "Microsoft": "Warning",
          "Microsoft.Hosting.Lifetime": "Information"
        }
      },
      "AllowedHosts": "*",
      "ConnectionStrings": {
        "ConnectionString": "Data Source=localhost;Initial Catalog=ReadConfig;Persist Security Info=True;User ID=sa;Password=12345;"
      },
      "MailConfig": {
        "Servers": {
          "MailGun": {
            "Pass": "65-1B-C9-B9-27-00",
            "Port": "587",
            "Host": "smtp.gmail.com"
          }
        },
        "Sender": {
          "Email": "example@gmail.com",
          "Pass": "123456"
        }
      }
    }
    

    第 3 步。从操作中读取配置值

    我在 Home 控制器中进行演示,如下所示:

    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            var connectionString = AppSettings.Instance.GetConnection("ConnectionString");
            var emailSender = AppSettings.Instance.Get<string>("MailConfig:Sender:Email");
            var emailHost = AppSettings.Instance.Get<string>("MailConfig:Servers:MailGun:Host");
    
            string returnText = " 1. Connection String \n";
            returnText += "  " +connectionString;
            returnText += "\n 2. Email info";
            returnText += "\n Sender : " + emailSender;
            returnText += "\n Host : " + emailHost;
    
            return Content(returnText);
        }
    }
    

    结果如下:

    Click to see result

    【讨论】:

      【解决方案12】:
      1. 像这样在此处添加所需的密钥。在这种情况下,它的 SecureCookies:

      1. 在startup.cs中,添加构造函数

         public Startup(IConfiguration configuration)
         {
             Configuration = configuration;
        
         }
         public IConfiguration Configuration { get; }
        
      2. 使用 Configuration["SecureCookies"] 访问设置

      【讨论】:

        【解决方案13】:

        我发现使用 .NET Core 3+ 最容易做到以下几点。我发现使用 HostBuilders 等的所有其他方法都有些冗长且不可读。这不是专门针对 ASP.Net,但您可以对其进行调整...

        这里有一个工作示例:https://github.com/NotoriousPyro/PyroNexusTradingAlertBot/blob/develop/PyroNexusTradingAlertBot/Program.cs

        创建 json:

        {
        "GlobalConfig": {
            "BlacklistedPairs": [ "USD", "USDT", "BUSD", "TUSD", "USDC", "DAI", "USDK" ]
        },
        "CoinTrackingConfig": {
            "Cookie1": "",
            "Cookie2": "",
            "ApiKey": "",
            "ApiSecret": "",
            "UpdateJobs": [
            {
                "Name": "Binance",
                "Path": "binance_api",
                "JobId": 42202
            },
            {
                "Name": "Bitfinex",
                "Path": "bitfinex_api",
                "JobId": 9708
            }
            ]
        },
        "DiscordConfig": {
            "BotToken": ""
        }
        }
        

        为 json 对象创建类:

        class GlobalConfig
        {
            public string[] BlacklistedPairs { get; set; }
        }
        class CoinTrackingConfig
        {
            public string Cookie1 { get; set; }
            public string Cookie2 { get; set; }
            public string ApiKey { get; set; }
            public string ApiSecret { get; set; }
            public List<CoinTrackingUpdateJobs> UpdateJobs { get; set; }
        }
        
        class CoinTrackingUpdateJobs
        {
            public string Name { get; set; }
            public string Path { get; set; }
            public int JobId { get; set; }
        }
        
        class DiscordConfig
        {
            public string BotToken { get; set; }
        }
        

        创建一个辅助类:

        private class Config
        {
            private IConfigurationRoot _configuration;
            public Config(string config) => _configuration = new ConfigurationBuilder()
                    .AddJsonFile(config)
                    .Build();
        
            public T Get<T>() where T : new()
            {
                var obj = new T();
                _configuration.GetSection(typeof(T).Name).Bind(obj);
                return obj;
            }
        }
        

        服务提供者选项和服务构造函数:

        public class DiscordServiceOptions
        {
            public string BotToken { get; set; }
        }
        
        public DiscordService(IOptions<DiscordServiceOptions> options, ILogger<DiscordService> logger)
        {
            _logger = logger;
            _client = new DiscordSocketClient();
            _client.Log += Log;
            _client.Ready += OnReady;
            _client.Disconnected += OnDisconnected;
            _client.LoginAsync(TokenType.Bot, options.Value.BotToken);
            _client.StartAsync();
        }
        

        像这样初始化它(将配置传入服务提供者 - IOptions 将在构建服务时传入):

        static async Task Main(string[] args)
        {
            var _config = new Config("config.json");
        
            var globalConfig = config.Get<GlobalConfig>();
            var coinTrackingConfig = config.Get<CoinTrackingConfig>();
            var discordConfig = config.Get<DiscordConfig>();
        
            _services = new ServiceCollection()
                .AddOptions()
                .Configure<DiscordServiceOptions>(options =>
                {
                    options.BotToken = discordConfig.BotToken;
                })
                .AddSingleton<IDiscordService, DiscordService>()
                .AddLogging(logging =>
                {
                    logging.SetMinimumLevel(LogLevel.Trace);
                    logging.AddNLog(new NLogProviderOptions
                    {
                        CaptureMessageTemplates = true,
                        CaptureMessageProperties = true
                    });
                })
                .BuildServiceProvider();
        }
        

        【讨论】:

        • 如何访问控制器中的globalConfig?
        【解决方案14】:

        我在 WPF (.NET Framework 5.0) 中遇到了类似的问题

        我所要做的就是注册它。

        services.AddSingleton<IConfiguration>(_configuration);
        

        配置本身是这样配置的(在 App.xaml.cs 中):

        var builder = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
        
        _configuration = builder.Build();
        

        【讨论】:

          【解决方案15】:
          1. appsetting.json

          {   
            "Settings": {      
              "ProjectName": "Sample Project"   
            }
          }
          
          1. 定义一个具有相同属性名称的类:
           public class Settings
           {
               public string ProjectName { get; set; }  
           }
          
          1. Startup.cs中添加配置:
          public void ConfigureServices(IServiceCollection services)
          {
              services.Configure<Settings>(Configuration.GetSection("Settings")); 
          }
          
          1. 注入控制器:
          public class TestController : Controller
          {
              private readonly Settings _settings;       
              
              public TestController(IOptions<Settings> settings)
              {
                   _settings = settings.Value;
              }
                 
              [AllowAnonymous]
              public async Task<IActionResult> test()
              {
                  var _projectname = _settings.ProjectName;
                          
                  return View();
              }
          }
          

          【讨论】:

          • 还需要在Startup.cs中声明和初始化Configuration。公共 IConfiguration 配置 { 获取; } 公共启动(IConfiguration 配置)=> 配置 = 配置;
          【解决方案16】:

          我认为最好的选择是:

          1. 创建一个模型类作为配置模式

          2. 在 DI 中注册: services.Configure(Configuration.GetSection("democonfig"));

          3. 从控制器中的 DI 获取值作为模型对象:

            private readonly your_model myConfig;
            public DemoController(IOptions<your_model> configOps)
            {
                this.myConfig = configOps.Value;
            }
            

          【讨论】:

            【解决方案17】:

            这往往会发生在 上,我认为这是因为人们如何配置launch.json

            基于this answer,我不得不将正在搜索的配置的基本路径重新配置为DLL's path,并且由于默认设置是可选的,因此很难在.net core 3.1 & net 上找到它5.0 应用程序。这是我重新配置的方式

            Program.cs:

            using System;
            using System.IO;
            using System.Reflection;
            using Microsoft.Extensions.Configuration;
            using Microsoft.AspNetCore.Hosting;
            using Microsoft.Extensions.Hosting;
            
            namespace API
            {
                public class Program
                {
                    public static int Main(string[] args)
                    {
                        CreateHostBuilder(args).Build().Run();
                        return 0;
                    }
            
                    public static IHostBuilder CreateHostBuilder(string[] args)
                    {
                        return Host.CreateDefaultBuilder(args)
                        .ConfigureAppConfiguration(c =>
                        {
                            var codeBase = Assembly.GetExecutingAssembly().Location;
                            var uri = new UriBuilder(codeBase);
                            var path = Uri.UnescapeDataString(uri.Path);
                            var assembyDirectory = Path.GetDirectoryName(path);
                            c.SetBasePath(assembyDirectory);
                        })
                        .ConfigureWebHostDefaults(webBuilder =>
                        {
                            webBuilder.UseStartup<Startup>();
                        })
                        ;
                    }
                }
            }
            

            我可以在Startup.cs 中正常访问配置:

            using Microsoft.AspNetCore.Builder;
            using Microsoft.AspNetCore.Hosting;
            using Microsoft.Extensions.Configuration;
            using Microsoft.Extensions.DependencyInjection;
            using Model;
            
            namespace API
            {
                public class Startup
                {
                    public IConfiguration Configuration { get; }
            
                    public Startup(IConfiguration configuration)
                    {
                        Configuration = configuration;
                    }
            
                    // This method gets called by the runtime. Use this method to add services to the container.
                    public void ConfigureServices(IServiceCollection services)
                    {
                        var myOptions = Configuration.To<ApiConfig>();
                        services.AddAuthentication(myOptions.Secret);
                        services.AddControllers();
                    }
            
                    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
                    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
                    {
                        app.UseRouting();
                        app.UseAuthentication();
                        app.UseAuthorization();
                        app.UseEndpoints(endpoints => { endpoints.MapControllers(); });
                    }
                }
            }
            

            【讨论】:

              【解决方案18】:

              就我而言,我从头开始创建所有内容,appsettings.json 也完全没有加载。经过一番调试,我发现该文件从未复制到“目标文件夹”。

              要修复它,我只需设置正确的文件属性。

              看起来像这样:

              【讨论】:

                【解决方案19】:

                我只是创建一个静态类并在 Startup.cs 中为其设置一个配置变量

                public static class GlobalConfig { 
                    public static IConfiguration config { get; set; } 
                }
                
                public class Startup
                {
                    public Startup(IConfiguration configuration)
                    {
                        GlobalConfig.config = configuration;
                
                    }
                }
                

                然后在任何地方使用它:

                var keyVal = GlobalConfig.config["key"];
                

                似乎是访问配置文件并使其在任何地方可用的最简单方法。

                【讨论】:

                • 您的答案可以通过额外的支持信息得到改进。请edit 添加更多详细信息,例如引用或文档,以便其他人可以确认您的答案是正确的。你可以找到更多关于如何写好答案的信息in the help center
                【解决方案20】:

                添加到 Abishek 的答案:

                如果您想将值导入静态类,那么只需使用(ReSharper 推荐):

                static IConfiguration conf = (JsonConfigurationExtensions.AddJsonFile(new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()), "appsettings.json").Build());
                
                private static string AuthorizationServiceURL { get; } = conf["ServiceUrls:AuthorizationUrl"];
                

                // appsettings.json
                {
                  "ServiceUrls": {
                    "AuthorizationUrl": "https://example.com/authorize"
                  } 
                }
                

                【讨论】:

                  【解决方案21】:

                  花了一个小时试图解决同样的问题,我的解决方案是在 csproj 中为 appconfig.json 添加 PreserveNewest/CopyAlways

                  <None Update="appsettings.json">
                    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
                  </None>
                  

                  【讨论】:

                    猜你喜欢
                    • 1970-01-01
                    • 2017-08-15
                    • 1970-01-01
                    • 1970-01-01
                    • 1970-01-01
                    • 2017-10-01
                    • 1970-01-01
                    相关资源
                    最近更新 更多