ASP.NET Core'daki bir .json dosyasından AppSettings değerleri nasıl okunur

AppSettings verilerimi dosya appsettings / Config .json dosyasında şu şekilde ayarladım:

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

Çevrimiçi .json dosyasından AppSettings değerlerini nasıl okuyacağımı araştırdım, ancak yararlı bir şey alamadım.

Denedim:

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

ASP.NET 4.0 ile bunu yapabilirsiniz biliyorum:

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

Ama bunu ASP.NET Core'da nasıl yapabilirim?

Bunun birkaç dönüşü oldu. Bu yanıtı ASP.NET Core 2.0 (26/02/2018 itibariyle) ile güncel olacak şekilde değiştirdim .

Bu çoğunlukla resmi belgelerden alınır :

ASP.NET uygulamanızdaki ayarlarla çalışmak için, yalnızca Configurationuygulamanızın Startupsınıfında bir örnek oluşturmanız önerilir . Ardından, tek tek ayarlara erişmek için Seçenekler desenini kullanın. Diyelim appsettings.jsonki şöyle bir dosya var:

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

}

Ve yapılandırmayı temsil eden bir POCO nesnemiz var:

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

Şimdi yapılandırmayı şu şekilde oluşturuyoruz 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();
    }
}

.NET Core 2.0'da varsayılanappsettings.json olarak kaydedileceğini unutmayın . appsettings.{Environment}.jsonGerekirse ortam başına bir yapılandırma dosyası da kaydedebiliriz .

Konfigürasyonumuzu kontrolörlerimize enjekte etmek istiyorsak, onu çalışma zamanına kaydetmemiz gerekecek. Bunu yoluyla yapıyoruzStartup.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"));
}

Ve bunu şu şekilde enjekte ediyoruz:

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

Tüm Startupsınıf:

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

İlk uzakta: Microsoft.Framework.ConfigurationModel derleme adı ve ad alanı Microsoft.Framework.Configuration olarak değiştirildi. Bu nedenle şunları kullanmalısınız: örn.

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

bağımlılık olarak project.json. 7 kurulu değilse beta5 veya 6 kullanın. Sonra böyle bir şey yapabilirsiniz 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();
}

Daha sonra config.json'dan bir değişkeni almak istiyorsanız, bunu kullanarak hemen alabilirsiniz:

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

veya AppSettings adında bir sınıf oluşturabilirsiniz:

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

ve hizmetleri aşağıdaki gibi yapılandırın:

public void ConfigureServices(IServiceCollection services)
{       
    services.AddMvc();

    services.Configure<MvcOptions>(options =>
    {
        //mvc options
    });

    services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
}

ve daha sonra buna benzer bir kontrolörle erişin:

public class HomeController : Controller
{
    private string _token;

    public HomeController(IOptions<AppSettings> settings)
    {
        _token = settings.Options.token;
    }
}

.NET Core 2.0 için işler biraz değişti. Başlangıç ​​yapıcısı, bir Configuration nesnesini parametre olarak alır ConfigurationBuilder. İşte benim:

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

Benim POCO, StorageOptionsyukarıda belirtilen nesnedir:

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

Ve yapılandırma aslında benim alt bölümüdür appsettings.jsonadlı dosyanın, 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"
  }
}

Ben ekleyeceğiz tek şey yapıcı değişti çünkü ben bir şey ekstra ihtiyaçlar bu yükü için yapılması gereken edip test etmedim, yani appsettings.<environmentname>.jsonkarşıt olarak appsettings.json.

.NET Core 2.2 ile ve mümkün olan en basit şekilde ...

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

appsettings.jsonotomatik olarak yüklenir ve kurucu veya eylem enjeksiyonu ile kullanılabilir ve ayrıca bir GetSectionyöntem vardır IConfiguration. Değiştirmeye gerek yok Startup.csya Program.csda tüm ihtiyacınız varsa appsettings.json.

Sadece jetonun değerini almak istiyorsanız şunu kullanın:

Configuration["AppSettings:token"]

.NET Core 3.0

Belki appsettings.json'dan bir değer almanın en iyi yolu değildir , ama basit ve benim uygulamada çalışır !!

Dosya appsettings.json

{
    "ConnectionStrings": {
        "DefaultConnection":****;"
    }

    "AppSettings": {
        "APP_Name": "MT_Service",
        "APP_Version":  "1.0.0"
    }
}

Denetleyici:

Üstte :

using Microsoft.Extensions.Configuration;

Kodunuzda:

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

Konsol uygulamaları için aşağıdakiler çalışır;

1. Aşağıdaki NuGet paketlerini ( .csproj) yükleyin ;

   <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.jsonKök düzeyinde oluşturun . Sağ tıklayın ve "Çıktı Dizine Kopyala " olarak "Daha yeniyse kopyala " olarak .

3. Örnek yapılandırma dosyası:

   {
     "AppConfig": {
       "FilePath": "C:\\temp\\logs\\output.txt"
     }
   }

4. program.cs

   configurationSection.Key ve configurationSection.Value config özelliklerine sahip olacak.

   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 için şunları yapabilirsiniz:

Anahtar / değer çiftlerinizi appsettings.json'da bildirin:

{
  "MyKey": "MyValue"
}

Startup.cs içindeki yapılandırma hizmetini enjekte edin ve hizmeti kullanarak değeri alın

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

Bunun iyi bir uygulama olduğundan şüpheliyim ama yerel olarak çalışıyor. (IIS web hizmetinde) yayımladığımda / dağıttığımda başarısız olursa bunu güncelleyeceğim.

Adım 1 - Bu montajı sınıfınızın üstüne ekleyin (benim durumumda, denetleyici sınıfı):

using Microsoft.Extensions.Configuration;

2. Adım - Bunu veya buna benzer bir şey ekleyin:

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

3. Adım - Bunu yaparak anahtarınızın değerini arayın (dizeyi döndürür):

config["NameOfYourKey"]

Sadece Yuval Itzchakov cevabını tamamlamak için.

Oluşturucu işlevi olmadan yapılandırmayı yükleyebilirsiniz, sadece enjekte edebilirsiniz.

public IConfiguration Configuration { get; set; }

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

Mevcut cevaplara ek olarak, bazen basitlik için uzatma yöntemlerine sahip olmanın yararlı olabileceğini belirtmek isterim IConfiguration.

JWT yapılandırmasını appsettings.json'da saklıyorum, böylece uzantı yöntemleri sınıfım aşağıdaki gibi görünüyor:

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

Size çok fazla satır kazandırır ve sadece temiz ve minimal kod yazarsınız:

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

IConfigurationÖrneği singleton olarak kaydetmek ve ihtiyacınız olan yere enjekte etmek de mümkündür - Autofac kapsayıcısını kullanıyorum:

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

Aynı şeyi MS Bağımlılık Enjeksiyonu ile de yapabilirsiniz:

services.AddSingleton<IConfigurationRoot>(appConfiguration);

İşte ASP.NET Core'un tam kullanım durumu!

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>

Sadece şeyleri değiştirmeye devam ediyorlar - Visual Studio'yu güncelledik ve tüm proje bombalarına sahip oldular, iyileşme yolunda ve yeni yol şöyle görünüyor:

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

Bu çizgiyi kaçırmaya devam ettim!

.SetBasePath(env.ContentRootPath)

.NET Core 2.1.0

1. Kök dizinde .json dosyasını oluşturun
2. Kodunuzda:

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

var config = builder.Build();

3. Aşağıdaki bağımlılıkları yükleyin:

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

4. Ardından, ÖNEMLİ: appsettings.json dosyasına sağ tıklayın -> Özellikler'e tıklayın -> Daha yeniyse Kopyala'yı seçin:

5. Son olarak şunları yapabilirsiniz:

   Yapılandırma [ "anahtar1"]

Yapılandırma dosyamın şöyle görüneceğini göz önünde bulundurarak:

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

Aşağıdaki kodu deneyebilirsiniz. Bu benim için çalışıyor.

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

Burada bağlantı dizesi ve uygulama ayarlarını almak için bir sınıf oluşturdum.

I Startup.cs dosyasını aşağıdaki gibi sınıf kaydetmeniz gerekir.

public class Startup
{

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

ASP.NET Core 3.1 için bu belgeleri takip edebilirsiniz:

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

Yeni bir ASP.NET Core 3.1 projesi oluşturduğunuzda, aşağıdaki yapılandırma satırına sahip olursunuz Program.cs:

Host.CreateDefaultBuilder(args)

Bu aşağıdakileri mümkün kılar:

1. ChainedConfigurationProvider: Varolan bir IConfiguration'ı kaynak olarak ekler. Varsayılan yapılandırma durumunda, ana makine yapılandırmasını ekler ve bunu uygulama yapılandırmasının ilk kaynağı olarak ayarlar.
2. JSON yapılandırma sağlayıcısını kullanarak appsettings.json.
3. appsettings.Environment.json, JSON yapılandırma sağlayıcısını kullanarak. Örneğin, appsettings.Production.json ve appsettings.Development.json.
4. Uygulama Geliştirme ortamında çalıştığında uygulama sırları.
5. Ortam Değişkenleri yapılandırma sağlayıcısını kullanan ortam değişkenleri.
6. Komut satırı yapılandırma sağlayıcısını kullanarak komut satırı bağımsız değişkenleri.

Bu, IConfigurationdeğerleri bir dize tuşu, hatta iç içe değerler ile enjekte edebileceğiniz ve getirebileceğiniz anlamına gelir . SevmekIConfiguration ["Parent:Child"];

Misal:

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

Bu "hile" miydi? Başlangıç ​​sınıfımda Yapılandırmamı statik hale getirdim ve sonra başka bir yerden erişebiliyorum:

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

Çağrı yoluyla bir nesne olarak denetleyicinin içine alın Get<YourType>():

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

İlk önce IConfiguration'ı enjekte etmeli ve daha sonra appsettings'den okumak için şu yöntemlerden birini kullanabilirsiniz:

1. Bölüm verisi alma

   var redisConfig = configuration.GetSection("RedisConfig");

2. Bir bölüm içinde değer alma

   var redisServer = configuration.GetValue<string>("RedisConfig:ServerName");

3. Bölüm içinde iç içe değer alma

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

.NET Core 2.2 yolu

(Şüphesiz Microsoft bunu bir sonraki .NET sürümünde tamamen farklı bir şeye değiştirecektir.)

1. appSettings.json

Böyle bir şeye benzeyebilir. Burada Setting1 ve Setting2'yi yükleyeceğiz

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

2. AppSettings.cs

POCO sınıf ayarı1 ve uygulaması2 tutmak için. Bu sınıf nesnesine appsettings.json dosyasını yükleyeceğiz. POCO sınıfının yapısı JSON dosyasıyla eşleşmelidir, özellikler istenirse diğer özellikler / sınıflar içinde yuvalanabilir.

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

3 Startup.cs

AppSettings nesnesine appSettings.json dosyasını yükleyin ve kullanmaya başlayın:

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'in en son yinelemesiyle, bunu herhangi bir üçüncü taraf bağımlılığı olmadan kolayca yapabilirsiniz.

Bunun için bir özeti oluşturdum , ancak bir JSON dosyasını okumak ve dinamik özellikler döndürmek için bu sınıfı kullanabilirsiniz.

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

Özellikle dotnet konsol uygulamamda bir appconfig.json kullanabilmek için bunu yaptım. Ben sadece benim Program.Mainfonksiyonu koymak :

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

Ve bu dynamicözellik için bir nesne döndürür . (İlkel değilse bir JsonElement). Dosyam appsettings.jsonşöyle görünüyor:

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