【问题标题】:How to read AppSettings values from a .json file in ASP.NET Core如何从 ASP.NET Core 中的 .json 文件中读取 AppSettings 值
【发布时间】:2025-12-03 08:10:02
【问题描述】:

我在 appsettings/Config .json 文件中设置了我的 AppSettings 数据,如下所示:

{
  "AppSettings": {
        "token": "1234"
    }
}

我在网上搜索了如何从 .json 文件中读取 AppSettings 值,但没有得到任何有用的信息。

我试过了:

var configuration = new Configuration();
var appSettings = configuration.Get("AppSettings"); // null
var token = configuration.Get("token"); // null

我知道使用 ASP.NET 4.0 你可以做到这一点:

System.Configuration.ConfigurationManager.AppSettings["token"];

但是如何在 ASP.NET Core 中做到这一点?

【问题讨论】:

标签: c# asp.net-core .net-core configuration app-config


【解决方案1】:

除了Ali's answer,还要在构造函数中注入IConfiguration对象:

appsettings.js

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "AppSettings": {
      "ServerUrl": "some url"
  }
  
}

定义 AppSettings 类

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

Startup.cs

 public class Startup
    {
        private readonly IConfiguration Configuration;
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            ...
        }
    }

控制器

    [Route("api/[controller]")]
    [ApiController]
    public class AuthenticationController : ControllerBase
    {
        private readonly AppSettings config;

        public AuthenticationController (IOptions<AppSettings> config)
        {
            this.config= config.Value;
        }

        [HttpGet("token")]

        public ActionResult Token()
        {
          var server=config.ServerUrl;

        }

适用于 .NET 5

【讨论】:

    【解决方案2】:

    对于 ASP.NET Core 3.1,您可以遵循此文档:

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

    当您创建新的 ASP.NET Core 3.1 项目或 .NET 5 项目时,您将在 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();
        }
    }
    

    【讨论】:

    • @Ogglas...WeatherForecastController()的调用者如何获取实现IConfiguration的类?
    【解决方案3】:

    这对我有用 .Net 5

    我有一个 appsettings.development.json 文件。我选择了“开发”环境,这就是我在 development.json 文件中有设置的原因。您可以将 appsettings.josn 与默认环境一起使用。

    使用此配置

    用配置属性创建了一个类

    在 Startup 中注册了我的通话

    我现在可以在我的控制器中访问

    【讨论】:

    • 我们可以用 JsonProperty 装饰模型属性(名称将类似于 appsettings 之一,但不是属性名称)?
    • 不确定,从未尝试过。你可以尝试更新我。
    • 我试过了,没有找到解决办法。我已经修改了 appsettings 键本身以符合我的项目需求
    【解决方案4】:

    派对迟到了,但如果有人发现了。

    您可以从 Microsoft.Extensions.Configuration 调用 IConfiguration;

    public static IConfiguration Configuration { get; }
    public static string MyAwesomeString = Configuration.GetSection("appSettings")["MyAwesomeString"].ToString();
    

    【讨论】:

      【解决方案5】:

      使用最新迭代的 netcoreapp 3.1,您可以非常简单地完成此操作,无需任何第三方依赖项。

      created a gist for this,但是你可以使用这个类来读取一个 JSON 文件并返回动态属性。

      using System.Text.Json;
      using System.IO;
      
      class ConfigurationLoader
      {
      
          private dynamic configJsonData;
          public ConfigurationLoader Load(string configFilePath = "appsettings.json")
          {
              var appSettings = File.ReadAllText(configFilePath);
              this.configJsonData = JsonSerializer.Deserialize(appSettings, typeof(object));
              return this;
          }
      
          public dynamic GetProperty(string key)
          {
              var properties = key.Split(".");
              dynamic property = this.configJsonData;
              foreach (var prop in properties)
              {
                  property = property.GetProperty(prop);
              }
      
              return property;
          }
      }
      

      我专门做了这个,所以我可以在我的 dotnet 控制台应用程序中使用 appconfig.json。我只是把它放在我的Program.Main 函数中:

      var config = new ConfigurationLoader();
      config.Load();
      Console.WriteLine(config.GetProperty("Environment.Name"));
      

      这将为属性返回一个dynamic 对象。 (如果不是原语,则为 JsonElement)。 我的appsettings.json 文件如下所示:

      {
        "Environment": {
          "Token": "abc-123",
          "Name": "Production"
        }
      }
      

      【讨论】:

      • 您不应为 .NET Core 中内置的内容创建自定义代码。你正在重新发明一个更糟糕的*。
      • 感谢您的建设性批评@kellen-stuart。当我遇到这个问题时,我无法找到 .NET Core 内置的东西来为我的控制台应用程序加载 appsettings。您能否为我指出适当的资源,以便我可以更新我的解决方案?
      • 使用ConfigurationBuilder是正确的方法;有一个方法叫AddJsonFiledocs.microsoft.com/en-us/dotnet/api/…
      【解决方案6】:

      对于 .NET Core 2.0,情况发生了一些变化。启动构造函数将配置对象作为参数,因此不需要使用ConfigurationBuilder。这是我的:

      public Startup(IConfiguration configuration)
      {
          Configuration = configuration;
      }
      
      public IConfiguration Configuration { get; }
      
      // This method gets called by the runtime. Use this method to add services to the container.
      public void ConfigureServices(IServiceCollection services)
      {
          services.Configure<StorageOptions>(Configuration.GetSection("AzureStorageConfig"));
      }
      

      我的 POCO 是顶部提到的 StorageOptions 对象:

      namespace FictionalWebApp.Models
      {
          public class StorageOptions
          {
              public String StorageConnectionString { get; set; }
              public String AccountName { get; set; }
              public String AccountKey { get; set; }
              public String DefaultEndpointsProtocol { get; set; }
              public String EndpointSuffix { get; set; }
      
              public StorageOptions() { }
          }
      }
      

      而配置实际上是我的appsettings.json文件的一个小节,命名为AzureStorageConfig

      {
        "ConnectionStrings": {
          "DefaultConnection": "Server=(localdb)\\mssqllocaldb;",
          "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=fictionalwebapp;AccountKey=Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==;EndpointSuffix=core.windows.net"
        },
        "Logging": {
          "IncludeScopes": false,
          "LogLevel": {
            "Default": "Warning"
          }
        },
      
        "AzureStorageConfig": {
          "AccountName": "fictionalwebapp",
          "AccountKey": "Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==",
          "DefaultEndpointsProtocol": "https",
          "EndpointSuffix": "core.windows.net",
          "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=fictionalwebapp;AccountKey=Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==;EndpointSuffix=core.windows.net"
        }
      }
      

      我唯一要补充的是,由于构造函数已经改变,我没有测试是否需要做一些额外的事情来加载appsettings.&lt;environmentname&gt;.json而不是appsettings.json

      【讨论】:

      • 请注意,您仍然需要将 .AddJsonFile("yourfile.json") 折腾到 ConfigConfiguration。 IE,你需要告诉它文件在哪里。在答案中没有看到。
      • Eric 我会重新测试,我不记得添加那行了;难道只有json文件名不是默认名时才需要吗?
      • 根据 MSDN,ASPNETCORE 2.0 不需要它,尽管它似乎对我也不起作用。 docs.microsoft.com/en-us/dotnet/api/…
      • 我可以确认我必须构建一个 ConfigurationBuilder() 对象并调用 AddJSONFile() 以将 appSettings.json 文件加载到配置字典中。这是 ASP.NET Core 2.0。这是一个错误,因为它与 MSDN 所说的相反?
      • 你能举个例子,你如何将 StorageOptions 注入你的控制器吗?如果我在 public HomeController(IOptions&lt;StorageOptions&gt; settings) 中使用 hug 的依赖注入方法,我会收到以下错误消息:模型绑定复杂类型不能是抽象类型或值类型,并且必须具有无参数构造函数。
      【解决方案7】:

      .NET Core 2.1.0

      1. 在根目录下创建.json文件
      2. 关于您的代码:
      var builder = new ConfigurationBuilder()
                      .SetBasePath(Directory.GetCurrentDirectory())
                      .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); 
      
      var config = builder.Build();
      

      3。安装以下依赖项:

      Microsoft.Extensions.Configuration
      Microsoft.Extensions.Configuration.json
      

      4.然后,重要: 右键单击 appsettings.json 文件 -> 单击“属性”-> 选择“如果较新则复制”:

      1. 最后,你可以这样做:

        配置[“key1”]

      考虑到我的配置文件看起来像这样:

      {
          "ConnectionStrings": "myconnection string here",
          "key1": "value here"
      }
      

      【讨论】:

        【解决方案8】:

        .NET Core 2.2 方式

        (毫无疑问,微软将在下一个 .NET 版本中再次将其更改为完全不同的东西。)

        1。 appSettings.json

        它可能看起来像这样。这里我们将加载 Setting1 和 Setting2

        {
          "Logging": {
            "LogLevel": {
              "Default": "Warning"
            }
          },
          "AllowedHosts": "*",
          "Setting1": "abc",
          "Setting2": 123
        }
        

        2。 AppSettings.cs

        POCO 类用于保存 Setting1 和 Setting2。我们将 appsettings.json 加载到这个类对象中。 POCO 类的结构应与 JSON 文件匹配,如果需要,属性可以嵌套在其他属性/类中。

        public class AppSettings
        {
            public string Setting1 { get; set; }
            public int Setting2 { get; set; }
        }
        

        3 Startup.cs

        将 appSettings.json 加载到您的 AppSettings 对象中并开始使用它:

        public class Startup
        {
            public Startup(IConfiguration configuration)
            {
                AppSettings settings = new AppSettings();
        
                Configuration = configuration;
                configuration.Bind(settings);
        
                // Now start using it
                string setting1 = settings.Setting1;
                int setting2 = settings.Setting2;
            }
        

        【讨论】:

        • new ConfigurationBuilder()...Build()config.Bind(appSettings) 的组合为我做了,谢谢
        【解决方案9】:

        首先您应该注入 IConfiguration,然后从 appsettings 中读取,您可以使用以下方法之一:

        1. 获取章节数据

          var redisConfig = configuration.GetSection("RedisConfig");
          
        2. 获取节内的值

          var redisServer = configuration.GetValue<string>("RedisConfig:ServerName");
          
        3. 获取节内的嵌套值

          var redisExpireMInutes = configuration.GetValue<int>("RedisConfig:ServerName:ExpireMInutes");
          

        【讨论】:

        • 注入适用于控制器,但如果我想在像here 这样的中间件中使用它怎么办?例如。我使用 Redis 作为中间件来缓存 http 响应。
        【解决方案10】:

        .NET Core 3.0

        也许这不是从 appsettings.json 中获取值的最佳方式,但它很简单,并且可以在我的应用程序中使用!!

        文件 appsettings.json

        {
            "ConnectionStrings": {
                "DefaultConnection":****;"
            }
        
            "AppSettings": {
                "APP_Name": "MT_Service",
                "APP_Version":  "1.0.0"
            }
        }
        

        控制器:

        在上面

        using Microsoft.Extensions.Configuration;
        

        在您的代码中:

        var AppName = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build().GetSection("AppSettings")["APP_Name"];
        

        【讨论】:

        • 非常简单。谢谢你,你帮了我!
        • AddJsonFile 在 ConfigurationBuilder 上不存在
        • @Essej:您需要安装 Microsoft.Extensions.Configuration.Json nuget 包才能使用 AddJsonFile 方法。
        • 神奇而简单的解决方案。
        • 很好的答案。请记住,这不会将用户机密合并到 appsettings.json
        【解决方案11】:

        你可以试试下面的代码。这对我有用。

        public class Settings
        {
            private static IHttpContextAccessor _HttpContextAccessor;
        
            public Settings(IHttpContextAccessor httpContextAccessor)
            {
                _HttpContextAccessor = httpContextAccessor;
            }
        
            public static void Configure(IHttpContextAccessor httpContextAccessor)
            {
                _HttpContextAccessor = httpContextAccessor;
            }
        
            public static IConfigurationBuilder Getbuilder()
            {
                var builder = new ConfigurationBuilder()
                  .SetBasePath(Directory.GetCurrentDirectory())
                  .AddJsonFile("appsettings.json");
                return builder;
            }
        
            public static string GetAppSetting(string key)
            {
                //return Convert.ToString(ConfigurationManager.AppSettings[key]);
                var builder = Getbuilder();
                var GetAppStringData = builder.Build().GetValue<string>("AppSettings:" + key);
                return GetAppStringData;
            }
        
            public static string GetConnectionString(string key="DefaultName")
            {
                var builder = Getbuilder();
                var ConnectionString = builder.Build().GetValue<string>("ConnectionStrings:"+key);
                return ConnectionString;
            }
        }
        

        这里我创建了一个类来获取连接字符串和应用设置。

        I Startup.cs 文件你需要注册类如下。

        public class Startup
        {
        
            public void Configure(IApplicationBuilder app, IHostingEnvironment env)
            {
                var httpContextAccessor = app.ApplicationServices.GetRequiredService<IHttpContextAccessor>();
                Settings.Configure(httpContextAccessor);
            }
        }
        

        【讨论】:

          【解决方案12】:

          通过调用Get&lt;YourType&gt;()将其作为对象放入控制器:

          public IActionResult Index([FromServices] IConfiguration config)
          {
              BillModel model = config.GetSection("Yst.Requisites").Get<BillModel>();
              return View(model);
          }
          

          【讨论】:

            【解决方案13】:

            使用 .NET Core 2.2,并以最简单的方式...

            public IActionResult Index([FromServices] IConfiguration config)
            {
                var myValue = config.GetValue<string>("MyKey");
            }
            

            appsettings.json 是通过构造函数或动作注入自动加载并可用的,IConfiguration 上还有一个 GetSection 方法。如果您只需要appsettings.json,则无需更改Startup.csProgram.cs

            【讨论】:

            • 更简单:var myValue = config["MyKey"]
            • ... 你可以这样做: config["Storage:ConnectionString"] 来获取 json 中的元素。我可以确认这种技术适用于 .net core 3 并适用于构造注入。
            【解决方案14】:

            以下适用于控制台应用程序;

            1. 安装以下 NuGet 包 (.csproj);

              <ItemGroup>
                  <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.2.0-preview2-35157" />
                  <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="2.2.0-preview2-35157" />
                  <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.2.0-preview2-35157" />
              </ItemGroup>
              
            2. 在根级别创建appsettings.json。右键单击它并将“复制到输出目录”作为“如果较新则复制”。

            3. 示例配置文件:

              {
                "AppConfig": {
                  "FilePath": "C:\\temp\\logs\\output.txt"
                }
              }
              
            4. 程序.cs

              configurationSection.KeyconfigurationSection.Value 将具有配置属性。

              static void Main(string[] args)
              {
                  try
                  {
              
                      IConfigurationBuilder builder = new ConfigurationBuilder()
                          .SetBasePath(Directory.GetCurrentDirectory())
                          .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
              
                      IConfigurationRoot configuration = builder.Build();
                      // configurationSection.Key => FilePath
                      // configurationSection.Value => C:\\temp\\logs\\output.txt
                      IConfigurationSection configurationSection = configuration.GetSection("AppConfig").GetSection("FilePath");
              
                  }
                  catch (Exception e)
                  {
                      Console.WriteLine(e);
                  }
              }
              

            【讨论】:

              【解决方案15】:

              他们只是不断地改变事物——刚刚更新了 Visual Studio,整个项目都被炸毁了,正在恢复的道路上,新的方式看起来像这样:

              public Startup(IHostingEnvironment env)
              {
                  var builder = new ConfigurationBuilder()
                      .SetBasePath(env.ContentRootPath)
                      .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                      .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
              
                  if (env.IsDevelopment())
                  {
                      // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709
                      builder.AddUserSecrets();
                  }
              
                  builder.AddEnvironmentVariables();
                  Configuration = builder.Build();
              }
              

              我一直错过这条线!

              .SetBasePath(env.ContentRootPath)
              

              【讨论】:

              • 我们如何使用相同的方法在测试项目中获取 AppSettings 值?
              • They just keep changing things。这。此页面上的几乎每个答案都仅适用于特定版本的 .Net Core。
              【解决方案16】:

              首先: Microsoft.Framework.ConfigurationModel 的程序集名称和命名空间已更改为 Microsoft.Framework.Configuration。所以你应该使用: 例如

              "Microsoft.Framework.Configuration.Json": "1.0.0-beta7"
              

              作为project.json 中的依赖项。如果您没有安装 7,请使用 beta5 或 6。 然后你可以在Startup.cs 中做这样的事情。

              public IConfiguration Configuration { get; set; }
              
              public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
              {
                   var configurationBuilder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
                      .AddJsonFile("config.json")
                      .AddEnvironmentVariables();
                   Configuration = configurationBuilder.Build();
              }
              

              如果您想从 config.json 中检索变量,您可以立即使用:

              public void Configure(IApplicationBuilder app)
              {
                  // Add .Value to get the token string
                  var token = Configuration.GetSection("AppSettings:token");
                  app.Run(async (context) =>
                  {
                      await context.Response.WriteAsync("This is a token with key (" + token.Key + ") " + token.Value);
                  });
              }
              

              或者您可以像这样创建一个名为 AppSettings 的类:

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

              并像这样配置服务:

              public void ConfigureServices(IServiceCollection services)
              {       
                  services.AddMvc();
              
                  services.Configure<MvcOptions>(options =>
                  {
                      //mvc options
                  });
              
                  services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
              }
              

              然后通过例如访问它像这样的控制器:

              public class HomeController : Controller
              {
                  private string _token;
              
                  public HomeController(IOptions<AppSettings> settings)
                  {
                      _token = settings.Options.token;
                  }
              }
              

              【讨论】:

              • 能否分享一下“AppSettings”的配置json以供参考
              • 我需要类中的整个 appSettings.json 配置,为此,我根据 JSON 设计了类并使用 Configuration.Get&lt;AppSettings&gt;() 反序列化整个文件而不是特定部分。
              【解决方案17】:

              我怀疑这是一种很好的做法,但它在本地有效。如果在我发布/部署(到 IIS Web 服务)时失败,我会更新它。

              第 1 步 - 将此程序集添加到您的类的顶部(在我的例子中,控制器类):

              using Microsoft.Extensions.Configuration;
              

              第 2 步 - 添加此内容或类似内容:

              var config = new ConfigurationBuilder()
                              .SetBasePath(Directory.GetCurrentDirectory())
                              .AddJsonFile("appsettings.json").Build();
              

              第 3 步 - 通过执行此操作调用您的密钥值(返回字符串):

              config["NameOfYourKey"]
              

              【讨论】:

              • 如果appsettings.json 在正确的目录中,我认为这应该没问题
              • 谢谢你:config["AppSettings:JWT_Secret"]
              【解决方案18】:

              对于 .NET Core 2.0,您可以:

              在 appsettings.json 中声明您的键/值对:

              {
                "MyKey": "MyValue"
              }
              

              在startup.cs中注入配置服务,使用服务获取值

              using Microsoft.Extensions.Configuration;
              
              public class Startup
              {
                  public void Configure(IConfiguration configuration,
                                        ... other injected services
                                        )
                  {
                      app.Run(async (context) =>
                      {
                          string myValue = configuration["MyKey"];
                          await context.Response.WriteAsync(myValue);
                      });
              

              【讨论】:

                【解决方案19】:

                这是 ASP.NET Core 的完整用例!

                articles.json

                {
                  "shownArticlesCount": 3,
                  "articles": [
                    {
                      "title": "My Title 1",
                      "thumbnailLink": "example.com/img1.png",
                      "authorProfileLink": "example.com/@@alper",
                      "authorName": "Alper Ebicoglu",
                      "publishDate": "2018-04-17",
                      "text": "...",
                      "link": "..."
                    },
                    {
                      "title": "My Title 2",
                      "thumbnailLink": "example.com/img2.png",
                      "authorProfileLink": "example.com/@@alper",
                      "authorName": "Alper Ebicoglu",
                      "publishDate": "2018-04-17",
                      "text": "...",
                      "link": "..."
                    },
                  ]
                }
                

                ArticleContainer.cs

                public class ArticleContainer
                {
                    public int ShownArticlesCount { get; set; }
                
                    public List<Article> Articles { get; set; }
                }
                
                public class Article
                {
                    public string Title { get; set; }
                
                    public string ThumbnailLink { get; set; }
                
                    public string AuthorName { get; set; }
                
                    public string AuthorProfileLink { get; set; }
                
                    public DateTime PublishDate { get; set; }
                
                    public string Text { get; set; }
                
                    public string Link { get; set; } 
                }
                

                Startup.cs

                public class Startup
                {
                    public IConfigurationRoot ArticleConfiguration { get; set; }
                
                    public Startup(IHostingEnvironment env)
                    {
                        ArticleConfiguration = new ConfigurationBuilder()
                            .SetBasePath(env.ContentRootPath)
                            .AddJsonFile("articles.json")
                            .Build();
                    }
                
                    public IServiceProvider ConfigureServices(IServiceCollection services)
                    {
                        services.AddOptions();
                
                        services.Configure<ArticleContainer>(ArticleConfiguration);
                    }
                }
                

                Index.cshtml.cs

                public class IndexModel : PageModel
                {
                    public ArticleContainer ArticleContainer { get;set; }
                
                    private readonly IOptions<ArticleContainer> _articleContainer;
                
                    public IndexModel(IOptions<ArticleContainer> articleContainer)
                    {
                        _articleContainer = articleContainer;
                    }
                
                    public void OnGet()
                    {
                        ArticleContainer = _articleContainer.Value;
                    }
                }
                

                Index.cshtml.cs

                <h1>@Model.ArticleContainer.ShownArticlesCount</h1>
                

                【讨论】:

                • “ASP.NET Core”哪个版本?
                【解决方案20】:

                除了现有的答案,我想提一下,为了简单起见,有时为IConfiguration 提供扩展方法 可能会很有用。

                我将 JWT 配置保存在 appsettings.json 中,因此我的扩展方法类如下所示:

                public static class ConfigurationExtensions
                {
                    public static string GetIssuerSigningKey(this IConfiguration configuration)
                    {
                        string result = configuration.GetValue<string>("Authentication:JwtBearer:SecurityKey");
                        return result;
                    }
                
                    public static string GetValidIssuer(this IConfiguration configuration)
                    {
                        string result = configuration.GetValue<string>("Authentication:JwtBearer:Issuer");
                        return result;
                    }
                
                    public static string GetValidAudience(this IConfiguration configuration)
                    {
                        string result = configuration.GetValue<string>("Authentication:JwtBearer:Audience");
                        return result;
                    }
                
                    public static string GetDefaultPolicy(this IConfiguration configuration)
                    {
                        string result = configuration.GetValue<string>("Policies:Default");
                        return result;
                    }
                
                    public static SymmetricSecurityKey GetSymmetricSecurityKey(this IConfiguration configuration)
                    {
                        var issuerSigningKey = configuration.GetIssuerSigningKey();
                        var data = Encoding.UTF8.GetBytes(issuerSigningKey);
                        var result = new SymmetricSecurityKey(data);
                        return result;
                    }
                
                    public static string[] GetCorsOrigins(this IConfiguration configuration)
                    {
                        string[] result =
                            configuration.GetValue<string>("App:CorsOrigins")
                            .Split(",", StringSplitOptions.RemoveEmptyEntries)
                            .ToArray();
                
                        return result;
                    }
                }
                

                它为您节省了很多行,并且您只需编写干净且最少的代码:

                ...
                x.TokenValidationParameters = new TokenValidationParameters()
                {
                    ValidateIssuerSigningKey = true,
                    ValidateLifetime = true,
                    IssuerSigningKey = _configuration.GetSymmetricSecurityKey(),
                    ValidAudience = _configuration.GetValidAudience(),
                    ValidIssuer = _configuration.GetValidIssuer()
                };
                

                也可以将IConfiguration 实例注册为单例并将其注入到任何你需要的地方 - 我使用 Autofac 容器,你是这样做的:

                var appConfiguration = AppConfigurations.Get(WebContentDirectoryFinder.CalculateContentRootFolder());
                builder.Register(c => appConfiguration).As<IConfigurationRoot>().SingleInstance();
                

                您可以对 MS 依赖注入做同样的事情:

                services.AddSingleton<IConfigurationRoot>(appConfiguration);
                

                【讨论】:

                  【解决方案21】:

                  这经历了一些波折。我已将此答案修改为与 ASP.NET Core 2.0 保持同步(截至 2018 年 2 月 26 日)。

                  这主要取自the official documentation

                  要使用 ASP.NET 应用程序中的设置,建议您仅在应用程序的 Startup 类中实例化 Configuration。然后,使用选项模式访问各个设置。假设我们有一个如下所示的appsettings.json 文件:

                  {
                    "MyConfig": {
                     "ApplicationName": "MyApp",
                     "Version": "1.0.0"
                     }
                  
                  }
                  

                  我们有一个代表配置的 POCO 对象:

                  public class MyConfig
                  {
                      public string ApplicationName { get; set; }
                      public int Version { get; set; }
                  }
                  

                  现在我们在Startup.cs中构建配置:

                  public class Startup 
                  {
                      public IConfigurationRoot Configuration { get; set; }
                  
                      public Startup(IHostingEnvironment env)
                      {
                          var builder = new ConfigurationBuilder()
                              .SetBasePath(env.ContentRootPath)
                              .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
                  
                          Configuration = builder.Build();
                      }
                  }
                  

                  请注意,appsettings.json 将在 .NET Core 2.0 中默认注册。如果需要,我们还可以为每个环境注册一个appsettings.{Environment}.json 配置文件。

                  如果我们想将我们的配置注入我们的控制器,我们需要将它注册到运行时。我们通过Startup.ConfigureServices这样做:

                  public void ConfigureServices(IServiceCollection services)
                  {
                      services.AddMvc();
                  
                      // Add functionality to inject IOptions<T>
                      services.AddOptions();
                  
                      // Add our Config object so it can be injected
                      services.Configure<MyConfig>(Configuration.GetSection("MyConfig"));
                  }
                  

                  我们像这样注入它:

                  public class HomeController : Controller
                  {
                      private readonly IOptions<MyConfig> config;
                  
                      public HomeController(IOptions<MyConfig> config)
                      {
                          this.config = config;
                      }
                  
                      // GET: /<controller>/
                      public IActionResult Index() => View(config.Value);
                  }
                  

                  完整的Startup 类:

                  public class Startup 
                  {
                      public IConfigurationRoot Configuration { get; set; }
                  
                      public Startup(IHostingEnvironment env)
                      {
                          var builder = new ConfigurationBuilder()
                              .SetBasePath(env.ContentRootPath)
                              .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
                  
                          Configuration = builder.Build();
                      }
                  
                      public void ConfigureServices(IServiceCollection services)
                      {
                          services.AddMvc();
                  
                          // Add functionality to inject IOptions<T>
                          services.AddOptions();
                  
                          // Add our Config object so it can be injected
                          services.Configure<MyConfig>(Configuration.GetSection("MyConfig"));
                      }
                  }
                  

                  【讨论】:

                  • 版本 "1.0.0-beta4" 不适用于我的 "1.0.0-alpha4"。非常感谢!
                  • 添加 nuget Microsoft.Extensions.Options.ConfigurationExtensions 后,它按预期工作。
                  • 这段代码与旧的 xml > 你们有多少人有时间做这个,只是为了保存一个字符串?
                  • 很好地解释了配置过程逻辑,但它忽略了一个重点:SetBasePath() 和 AddJsonFile() 是扩展方法,在框架中的单独程序集中深陷其中。因此,为了开始使用,除了 Microsoft.Extensions.Configuration 之外,还需要安装 Microsoft.Extensions.Configuration.FileExtensions 和 Microsoft.Extensions.Configuration.Json。
                  • 仅检索应用程序设置就令人难以置信。
                  【解决方案22】:

                  这是“作弊”吗?我只是将 Startup 类中的配置设为静态,然后我可以从其他任何地方访问它:

                  public class Startup
                  {
                      // This method gets called by the runtime. Use this method to add services to the container.
                      // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
                      public Startup(IHostingEnvironment env)
                      {
                          var builder = new ConfigurationBuilder()
                              .SetBasePath(env.ContentRootPath)
                              .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                              .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                              .AddEnvironmentVariables();
                  
                          Configuration = builder.Build();
                      }
                  
                      public static IConfiguration Configuration { get; set; }
                  

                  【讨论】:

                  • 我知道这是旧的,但人们仍在阅读它。这不是一个好习惯。这会创建对代码的一部分的直接引用,而不是使用 DI 来加载它,当您创建代码映射时,会有太多地方指向您的代码,您将不得不重构。
                  • 为什么“直接引用我的代码”不好? DI 过度工程化是一项简单的任务。
                  【解决方案23】:

                  只是为了补充 Yuval Itzchakov 的答案。

                  你可以在没有构建器功能的情况下加载配置,你可以注入它。

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

                  【讨论】:

                    【解决方案24】:

                    如果您只想获取令牌的值,请使用

                    Configuration["AppSettings:token"]

                    【讨论】:

                    • 为此,您需要事先通过 ConfigurationBuilder 初始化一个 IConfiguration 实例。