.Net कोर में appsettings.json से मूल्य प्राप्त करना


161

मुझे यकीन नहीं है कि मैं यहां क्या याद कर रहा हूं, लेकिन मैं अपने नेटसेट अनुप्रयोग में अपने appsettings.json से मूल्यों को प्राप्त करने में सक्षम नहीं हूं। मेरे पास मेरे appsettings.json हैं:

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

चालू होना:

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

नमूना:

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

नियंत्रक:

public class HomeController : Controller
{
    private readonly AppSettings _mySettings;

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

_mySettingsहमेशा अशक्त रहता है। क्या कुछ ऐसा है जो मुझे यहाँ याद आ रहा है?


3
कॉन्फ़िगरेशन का उपयोग करने के तरीके पर कृपया दस्तावेज़ पढ़ें । आपने अपने स्टार्टअप क्लास में कॉन्फ़िगरेशन को अनुचित तरीके से सेट किया है।
प्रहार

प्रलेखन के लिए धन्यवाद। यह मददगार था।
अमन

यह भी IConfiguration की निर्भरता इंजेक्शन का उपयोग करके सरल किया जा सकता है। जिसे यहाँ समझाया गया है कोडिंग-issues.com/2018/10/…
Ranadheer Reddy

जवाबों:


228

कार्यक्रम और स्टार्टअप क्लास

.NET कोर 2.x

आपको कंस्ट्रक्टर IConfigurationमें नया करने की आवश्यकता नहीं है Startup। इसके कार्यान्वयन को डीआई सिस्टम द्वारा इंजेक्ट किया जाएगा।

// 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एप्लेटिंग फाइलों को लोड करने के लिए बताना होगा।

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

मान मिल रहा है

ऐसे कई तरीके हैं जिनसे आप एप्लिकेशन सेटिंग्स से कॉन्फ़िगर किए गए मान प्राप्त कर सकते हैं:

आइए बताते हैं आपके 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>अच्छा काम करता है अगर आप केवल एप्लिकेशन सेटिंग से एक या दो मूल्यों की जरूरत है। लेकिन अगर आप ऐप सेटिंग्स से कई वैल्यूज़ प्राप्त करना चाहते हैं, या आप उन हार्ड स्ट्रिंग्स को कई जगहों पर कोड नहीं करना चाहते हैं, तो विकल्प पैटर्न का उपयोग करना आसान हो सकता है । विकल्प पैटर्न पदानुक्रम / संरचना का प्रतिनिधित्व करने के लिए कक्षाओं का उपयोग करता है।

विकल्प पैटर्न का उपयोग करने के लिए:

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

मैं अपना डेटा रखने वाले वर्ग में मूल्यों का उपयोग कैसे कर सकता हूं?
लुकास हिरोनिमस एडलर

1
@LukasHieronimusAdler: आप IOptionsSnapshot<T>इसके बजाय उपयोग करना चाह सकते हैं IOptions<T>। आप इस लेख पर नज़र डाल सकते हैं: offer.solutions/blog/articles/2017/02/17/… । हालांकि मुझे खुद इसे आजमाने का मौका नहीं मिला।
डेविड लिआंग

2
क्या आप इसे स्निपेट की तरह सरल बना सकते हैं?
सियाफुल निज़ाम याह्या जूल

8
पूर्ण स्टैक से पीछे की ओर एक भयानक कदम क्या है ।net
हारून

4
ठीक है, इसलिए .NET कोर 3 के लिए आपको Microsoft.Extensions.Options.ConfigurationExtensions पैकेज की आवश्यकता है और यह ठीक काम करता है
टॉमस ब्रूनर

50

बस एक 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"];

3
उत्पादन में इसका उपयोग न करें। यह तरीका हमारे वेब एप में मेमोरी लीक का कारण बना। यदि आप netcore का उपयोग कर रहे हैं, तो आप IConfiguration को सचमुच कहीं भी इंजेक्ट कर सकते हैं, बस ऊपर दिए गए उत्तर देखें।
एंड्रे मंटास

49

कोर 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; }
}

1
नेस्टेड वस्तुओं के बारे में क्या?
आर्थर एटाउट

8
निहित वस्तुओं को विन्यास के साथ प्राप्त किया जा सकता है ["MyConfig: SomeNested"]
WeHaveCookies

1
जैसा कि फ़ाइल में देखा जा सकता है github.com/aspnet/AspNetCore/blob/master/src/DefaultBuilder/src/… ऑन लाइन 167 ASP.NET कोर वर्तमान में appsettings.json+ लोड करता है appsettings.{env.EnvironmentName}.json। इसलिए यह कथन कि ASP.NET Core केवल विकास, स्टेजिंग और उत्पादन appsettings.json फ़ाइलों को लोड करता है, वर्तमान में गलत है।
mvdgun

1
तो क्या मैं ASPNETCORE_ENVIRONMENTहर बार विंडोज चर सेट करने वाला हूं ? चीजें .Net में आसान थीं। 4. इन JSON कट्टरपंथियों ने इसे बड़ा समय दिया
टूलकिट

@ टूलकिट आप विश्व स्तर पर पर्यावरण चर सेट कर सकते हैं। docs.microsoft.com/en-us/aspnet/core/fundamentals/…
असीम गौतम

29

मुझे लगता है कि डीआई द्वारा सबसे सरल तरीका है। नियंत्रक में पहुंचने का एक उदाहरण।

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

5
अन्य उत्तरों को पढ़ना, यह सबसे अच्छा होना चाहिए।
१६

मुझे याद आ रहा था services.AddSingleton(Configuration);, अब यह काम करता है
आर्थर मेडिएरोस

12

स्टार्टअप क्लास के कंस्ट्रक्टर में, आप ऐपसेटिंग्स.जॉन और कई अन्य सेटिंग्स का उपयोग कर सकते हैं जो इंजेक्ट किए गए आईसीऑनफ्लोरेंसेशन का उपयोग करते हैं:

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

2
यह 'विन्यास ["दादाजी: पिता: बाल"] वाक्यविन्यास था जिसने मेरी मदद की।
जैक्स ओलिवियर

2
यह जिस तरह से संरचित, स्पष्ट और बिंदु तक है, यह एक उत्कृष्ट उत्तर है। महान संचार
ज्योलीसॉफ्ट


1

मेरे मामले में यह विन्यास वस्तु पर बिंद () पद्धति का उपयोग करने के रूप में सरल था। और फिर 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"
    }
  }

1

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

मैं IConfiguration["Parent:Child"]सिंटैक्स के बारे में और कहाँ सीख सकता हूँ ?
xr280xr

0

मुझे लगता है कि सबसे अच्छा विकल्प है:

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

0

Asp.net कोर 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 ऑब्जेक्ट के लिए प्रारंभिक कॉन्फ़िगरेशन

एप्लिकेशन शुरू होने पर हमें appettings.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. एक कार्रवाई से कॉन्फ़िगरेशन मान पढ़ें

मैं नीचे दिए गए अनुसार होम कंट्रोलर में डेमो एक्शन करता हूँ:

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

और नीचे परिणाम है:

रिजल्ट देखने के लिए क्लिक करें

अधिक जानकारी के लिए, आप अधिक विवरण कोड के लिए asp.net कोर में appsettings.json से मान प्राप्त कर सकते हैं ।


0

इसका सरल: 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();
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.