從 .net 核心中的 appsettings.json 獲取價值

Question

不知道我在這里遺漏了什么，但我無法從我的 .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"));
    }
}

Model：

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

Controller：

public class HomeController : Controller
{
    private readonly AppSettings _mySettings;

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

_mySettings始終為 null。 我在這里缺少什么嗎？

Answer 1

程序和啟動類

.NET 核心 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 核心 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<T>簡單方法
• 使用選項模式

假設您的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<T>效果很好。 但是，如果您想從應用程序設置中獲取多個值，或者您不想在多個位置對這些鍵字符串進行硬編碼，則使用Options Pattern可能會更容易。 選項模式使用類來表示層次結構/結構。

使用選項模式：

1. 定義類來表示結構
2. 注冊這些類綁定的配置實例
3. 將IOptions<T>注入要獲取值的控制器/類的構造函數中

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<AppIdentitySettings> ：

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);
    }
}

Answer 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"];

Answer 3

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

appsettings.json文件鏈接到ASPNETCORE_ENVIRONMENT變量。

ASPNETCORE_ENVIRONMENT可以設置為任何值，但框架支持三個值： Development 、 Staging和Production 。 如果ASPNETCORE_ENVIRONMENT未設置，則默認為Production 。

對於這三個值，這些appsettings.ASPNETCORE_ENVIRONMENT.json文件開箱即用 - appsettings.Staging.json 、 appsettings.Development.json和appsettings.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; }
}

Answer 4

我想最簡單的方法是通過 DI。 進入控制器的示例。

// 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");
        ...
    }
}

Answer 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"
    }
  }

Answer 6

    public static void GetSection()
    {
        Configuration = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json")
            .Build();

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

    }

Answer 7

對於 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();
    }
}

Answer 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() };
    }
}

Answer 9

很簡單：在 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();

Answer 10

就我而言，它很簡單，就像在 Configuration 對象上使用 Bind() 方法一樣。 然后將對象作為單例添加到 DI 中。

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

指令對象可以根據需要變得復雜。

{  
 "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"
    }
  }

Answer 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);
    }
}

結果如下：

點擊查看結果

Answer 12

1. 像這樣在此處添加所需的密鑰。 在這種情況下，它的 SecureCookies：

2. 在startup.cs中，添加構造函數

    public Startup(IConfiguration configuration) { Configuration = configuration; } public IConfiguration Configuration { get; }

3. 使用 Configuration["SecureCookies"] 訪問設置

Answer 13

我認為最好的選擇是：

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; }

Answer 14

這往往發生在vscode 中，因為我認為這是因為人們如何配置launch.json 。

根據這個答案，我不得不將正在搜索的配置的基本路徑重新配置為DLL 路徑的基本路徑，並且由於默認設置是可選的，因此很難在 .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(); });
        }
    }
}

Answer 15

我發現使用 .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();
}

Answer 16

就我而言，我從頭開始創建了所有內容，而且appsettings.json也根本沒有加載。 經過一些調試，我發現該文件從未復制到“目標文件夾”。

要修復它，我只需要設置正確的文件屬性。

它看起來像這樣：

Answer 17

我在 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();

Answer 18

1. appsetting.json

---

{   
  "Settings": {      
    "ProjectName": "Sample Project"   
  }
}

2. 定義一個具有相同屬性名稱的類：

 public class Settings
 {
     public string ProjectName { get; set; }  
 }

3. 在Startup.cs添加配置：

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<Settings>(Configuration.GetSection("Settings")); 
}

4. 注入控制器：

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();
    }
}

Answer 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"];

似乎是訪問配置文件並使其在任何地方可用的最簡單方法。

Answer 20

添加到阿比舍克的答案：

如果要將值導入靜態類，則只需使用（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"
  } 
}

Answer 21

花了一個小時試圖解決同樣的問題，我的解決方案是在 csproj 中為 appconfig.json 添加 PreserveNewest/CopyAlways

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

Answer 22

這是對 .NET 框架和核心的抽象：web.config、app.config 和 appsettings.json

    static SafeDictionary<string, string> _appSettings;

    public static SafeDictionary<string, string> AppSettings {
        get {
            if (_appSettings == null)
            {
                _appSettings = ConfigurationManager.AppSettings
                    .ToDictionary()
                    .ToSafe();

                BuildAppSettings( JsonAppSettings, "");

            }

            return _appSettings;
        }
    }


    static SafeDictionary<string, string> _connectionStrings;

    public static SafeDictionary<string, string> ConnectionStrings
    {
        get
        {
            if (_connectionStrings == null)
            {
                _connectionStrings = ConfigurationManager.ConnectionStrings
                    .Cast<ConnectionStringSettings>()
                    .ToDictionary(x => x.Name, x => x.ConnectionString)
                    .ToSafe();

                foreach (var jp in JsonAppSettings["ConnectionStrings"].Cast<JProperty>())
                    _connectionStrings.Add(jp.Name, jp.Value.ToString() );

            }

            return _connectionStrings;
        }
    }

https://github.com/bitministry/common