ASP.NET Core의 .json 파일에서 AppSettings 값을 읽는 방법

파일 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에서 어떻게해야합니까?

이것은 약간의 꼬임이있었습니다. 이 답변을 ASP.NET Core 2.0 (2018 년 2 월 26 일 현재)으로 최신으로 수정했습니다 .

이것은 대부분 공식 문서 에서 가져온 것입니다 .

ASP.NET 응용 프로그램에서 설정 작업을하려면 Configuration응용 프로그램 Startup클래스 에서만 인스턴스를 생성하는 것이 좋습니다 . 그런 다음 옵션 패턴을 사용하여 개별 설정에 액세스하십시오. 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 코어 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"));
    }
}

우선 : 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;
    }
}

.NET Core 2.0의 경우 상황이 약간 변경되었습니다. 시작 생성자는 Configuration 개체를 매개 변수로 사용하므로을 사용할 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.<environmentname>.json반대 appsettings.json.

.NET Core 2.2 및 가장 간단한 방법으로 ...

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

appsettings.json생성자 또는 액션 삽입을 통해 자동으로로드되고 사용 가능하며 GetSection메소드 IConfiguration도 있습니다. 변경할 필요가 Startup.cs없거나 Program.cs필요한 것이 모두입니다 appsettings.json.

토큰의 가치를 얻으려면 다음을 사용하십시오.

Configuration["AppSettings:token"]

.NET 코어 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"];

다음은 콘솔 응용 프로그램에서 작동합니다.

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. Program.cs

   configurationSection.Key및 configurationSection.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);
       }
   }

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

이것이 좋은 습관인지 의심하지만 로컬에서 작동하고 있습니다. IIS 웹 서비스에 게시 / 배포 할 때 실패하면이를 업데이트합니다.

1 단계-이 어셈블리를 클래스 상단에 추가하십시오 (제 경우에는 컨트롤러 클래스).

using Microsoft.Extensions.Configuration;

2 단계-이것 또는 이와 유사한 것을 추가하십시오 :

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

3 단계-이 작업을 수행하여 키 값을 호출합니다 (문자열 반환).

config["NameOfYourKey"]

Yuval Itzchakov의 답변을 보완하기 위해.

빌더 기능없이 구성을로드 할 수 있습니다. 삽입하면됩니다.

public IConfiguration Configuration { get; set; }

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

기존 답변 외에도 간결성을 위해 확장 방법 을 사용 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 Dependency Injection으로 동일한 작업을 수행 할 수 있습니다.

services.AddSingleton<IConfigurationRoot>(appConfiguration);

다음은 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>

그들은 단지 변화를 계속하고 있습니다 – 방금 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)

.NET 코어 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 파일을 마우스 오른쪽 버튼으로 클릭하고-> 속성을 ​​클릭 한 다음-최신 인 경우 복사를 선택하십시오.

5. 마지막으로 다음을 수행 할 수 있습니다.

   config [ "key1"]

내 설정 파일은 다음과 같습니다.

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

아래 코드를 시도해보십시오. 이것은 나를 위해 일하고 있습니다.

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

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. JSON 구성 제공자를 사용하는 appsettings.json
3. JSON 구성 제공자를 사용하는 appsettings.Environment.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();
    }
}

이 "속임수"입니까? 방금 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; }

호출을 통해 컨트롤러 내부에서 객체로 가져옵니다 Get<YourType>().

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

먼저 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");

.NET Core 2.2 방식

의심의 여지없이 Microsoft는 다음 .NET 버전에서 완전히 다른 것으로 다시 변경합니다.

1. appSettings.json

다음과 같이 보일 수 있습니다. 여기서 Setting1과 Setting2를로드합니다

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

2. AppSettings.cs

마시고 클래스는 설정 1 및 설정 2를 개최합니다. 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;
    }

netcoreapp 3.1의 최신 버전을 사용하면 타사 종속성없이 간단히 수행 할 수 있습니다.

나는 이것에 대한 요점을 만들어 ,하지만 당신은 동적 속성을 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;
    }
}

내 닷넷 콘솔 응용 프로그램에서 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"
  }
}