ASP.NET कोर में एक .json फ़ाइल से AppSettings मान कैसे पढ़ें

247

मैंने अपने AppSettings डेटा को इस तरह से फ़ाइल appsettings / config .json में सेट किया है:

{
  "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 कोर में यह कैसे करूँ?

c#  .net  asp.net-core  .net-core 
— Oluwafemi
स्रोत
— राजमिस्त्री
— MDMoore313
यह सिर्फ IConfiguration (.net कोर 2.0) की निर्भरता इंजेक्शन का उपयोग करके भी सरल किया जा सकता है। जिसे यहाँ समझाया गया है कोडिंग-issues.com/2018/10/…
— रणधीर रेड्डी
@ रानाधीरेड्डी, निर्भरता इंजेक्शन नियंत्रकों के लिए काम करता है। लेकिन क्या होगा अगर किसी को मिडलवेयर में एक मूल्य पढ़ने की ज़रूरत है?
— अलेक्जेंडर रयान

जवाबों:

320

इससे कुछ मोड़ और मोड़ आए हैं। मैंने इस उत्तर को ASP.NET Core 2.0 के साथ अद्यतित किया है (26/02/2018 तक) के ।

यह ज्यादातर आधिकारिक दस्तावेज से लिया गया है :

अपने 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();
    }
}

ध्यान दें कि .NET कोर 2.0 में डिफ़ॉल्ट रूप से पंजीकृत कियाappsettings.json जाएगा । हम भी एक रजिस्टर कर सकते हैं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"));
    }
}
— युवल इट्ज़चकोव
स्रोत
3
संस्करण "1.0.0-beta4"मेरा नहीं पर काम करता है "1.0.0-alpha4"। आपका बहुत बहुत धन्यवाद!
— ओलुवाफेमी
2
मुझे यूटिलिटी क्लास से एक और लेयर पर जाने के लिए सेटिंग की जरूरत है, इसलिए मुझे इस पब्लिक स्टैटिक स्ट्रिंग GetConnectionString () {if (string .sNullOrEmpty (connectionString)) {var बिल्डर = new configuration_uilder () .AddJsonFile ("config.json) की आवश्यकता है। "); विन्यास = बिल्डर.बिल्ड (); connectionString = configuration.Get ("डेटा: DefaultConnection: ConnectionString"); }} कनेक्शन कनेक्शन वापस; }
— dnxit
2
मुझे मिलता हैArgument 2: cannot convert from 'Microsoft.Extensions.Configuration.IConfigurationSection' to 'System.Action<....Settings>'
— पीटर
5
नगेट जोड़ने के बाद Microsoft.Extensions.Options.ConfigurationExtensionsयह उम्मीद के मुताबिक काम किया।
— पीटर
2
विन्यास प्रक्रिया तर्क की अच्छी व्याख्या है, लेकिन यह एक प्रमुख बिंदु को याद करता है: SetBasePath () और AddJsonFile () विस्तार विधियां हैं, अलग-अलग विधानसभाओं में ढांचे में गहराई से बरी हुई हैं। तो आरंभ करने के लिए, किसी को Microsoft.Extensions.Configuration.FileExtensions और Microsoft.Extensions.Configuration.Json Microsoft.Extensions.Configuration को स्थापित करने की आवश्यकता है।
— बोहिदार स्टोयनेफ़
63

सबसे पहले: Microsoft.Framework.ConfigurationModel का असेंबली नाम और नाम स्थान बदलकर Microsoft.Framework.Configuration हो गया है। इसलिए आपको उपयोग करना चाहिए: जैसे

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

में निर्भरता के रूप में project.json । यदि आपके पास 7 इंस्टॉल नहीं है तो बीटा 5 या 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" के लिए कॉन्फ़िगरेशन जसन साझा कर सकते हैं
— अंकित मोरी
मुझे पूरे appSettings.json को क्लास में कॉन्फ़िगर करने की आवश्यकता है, इसके लिए, मैंने JSON के अनुसार क्लास डिज़ाइन किया है और Configuration.Get<AppSettings>()एक विशिष्ट अनुभाग के बजाय संपूर्ण फ़ाइल को डीसर्विलाइज़ करने के लिए उपयोग करता है।
— निलय
52

.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.<environmentname>.jsonके रूप में करने का विरोध किया appsettings.json।

— MDMoore313
स्रोत
बस एक नोट जिसे आपको अभी भी टॉस करने की आवश्यकता है ।AddJsonFile ("yourfile.json") को कॉन्फ़िगर करें कॉन्फिगरेशन। IE, आपको यह बताना होगा कि फ़ाइल कहाँ है। जवाब में यह नहीं देखा।
— एरिक
एरिक मैं उसे फिर से लिखूंगा, मुझे उस लाइन को जोड़ना याद नहीं है; क्या यह आवश्यक हो सकता है केवल अगर json फ़ाइल का नाम डिफ़ॉल्ट नाम नहीं है?
— एमडीमोहोर313
MSDN प्रति, यह ASPNETCORE 2.0 के लिए आवश्यक नहीं है, हालांकि यह मेरे लिए भी काम नहीं करता है। docs.microsoft.com/en-us/dotnet/api/…
— Sat
1
मैं पुष्टि कर सकता हूं कि मुझे configBuilder () ऑब्जेक्ट का निर्माण करना था और AddSSONings.json फ़ाइलों को कॉन्फिगरेशन डिक्शनरी में लोड करने के लिए AddJSONFile () को कॉल करना था। यह ASP.NET Core 2.0 है। क्या यह एक बग है क्योंकि यह MSDN के विपरीत कहता है?
— सत थिरु
1
क्या आप एक उदाहरण दे सकते हैं कि आप अपने नियंत्रकों में StorageOptions को कैसे इंजेक्ट करते हैं? अगर मैं निर्भरता इंजेक्शन के साथ गले लगाने के दृष्टिकोण का उपयोग करता public HomeController(IOptions<StorageOptions> settings)हूं, तो मुझे यह त्रुटि संदेश मिलता है: मॉडल बाध्य जटिल प्रकार अमूर्त या मान प्रकार नहीं होना चाहिए और एक पैरामीटर रहित निर्माता होना चाहिए।
— जेपीसी
30

.NET कोर 2.2 के साथ, और सबसे सरल तरीके से संभव ...

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

appsettings.jsonस्वचालित रूप से लोड किया गया है और कंस्ट्रक्टर या एक्शन इंजेक्शन के माध्यम से उपलब्ध है, और साथ ही एक GetSectionविधि IConfigurationभी है। वहाँ में परिवर्तन करने की कोई जरूरत नहीं है Startup.csया Program.csअगर है आप सभी की जरूरत appsettings.json।

— tnJed
स्रोत
2
और भी सरल:var myValue = config["MyKey"]
— जौकैब
... और आप कर सकते हैं: config ["भंडारण: ConnectionString"] के भीतर तत्वों को पाने के लिए। मैं पुष्टि कर सकता हूं कि यह तकनीक .net कोर 3 पर काम करती है और निर्माण इंजेक्शन पर काम करती है।
— मेरियो मेयरेलस
29

यदि आप टोकन का मूल्य प्राप्त करना चाहते हैं तो उपयोग करें

Configuration["AppSettings:token"]

— kodebot
स्रोत
4
यह काम करने के लिए, आपको पहले से कॉन्फ़िगरेशनब्यूलेस्ट के माध्यम से एक आईसीऑनफिगरेशन उदाहरण शुरू करने की आवश्यकता है।
— 19 Г И О И О
20

.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"];
— अलेक्जेंडर एस।
स्रोत
बहुत सीधा। इसके लिए धन्यवाद, आपने मेरी मदद की!
— मैट
AddJsonFile का विन्यास विन्यास पर मौजूद नहीं है
— Essej
10

कंसोल अनुप्रयोगों के लिए निम्नलिखित कार्य करता है;

  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);
    }
}
— तोमन शिपही
स्रोत
8

.NET कोर 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);
        });
— क्रिस हैल्क्रो
स्रोत
8

मुझे संदेह है कि यह अच्छा अभ्यास है लेकिन यह स्थानीय स्तर पर काम कर रहा है। यदि मैं प्रकाशित / तैनात (IIS वेब सेवा के लिए) विफल रहता हूं तो मैं इसे अपडेट करूंगा।

चरण 1 - इस विधानसभा को अपनी कक्षा के शीर्ष पर जोड़ें (मेरे मामले में, नियंत्रक वर्ग):

using Microsoft.Extensions.Configuration;

चरण 2 - इसे या कुछ इस तरह से जोड़ें:

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

चरण 3 - ऐसा करके अपनी कुंजी का मूल्य बताएं (रिटर्न स्ट्रिंग):

config["NameOfYourKey"]
— एरिक मिलियट-मार्टिनेज
स्रोत
मुझे लगता है कि यह ठीक होना चाहिए बशर्ते कि appsettings.jsonयह सही डायरेक्टरी में हो
— Ju66ernaut
7

बस युवल इट्ज़चकोव उत्तर के पूरक के लिए।

आप बिल्डर फ़ंक्शन के बिना कॉन्फ़िगरेशन लोड कर सकते हैं, आप बस इसे इंजेक्ट कर सकते हैं।

public IConfiguration Configuration { get; set; }

public Startup(IConfiguration configuration)
{
   Configuration = configuration;
}
— टियागो बारसो
स्रोत
6

मौजूदा उत्तरों के अलावा, मैं यह उल्लेख करना चाहूंगा कि कभी-कभी यह सरलता के लिए विस्तार विधियों के लिए उपयोगी हो सकता है IConfiguration।

मैं appsWings.json में JWT कॉन्फिग को रखता हूं ताकि मेरी एक्सटेंशन विधियां इस प्रकार दिखें:

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सिंग्लटन के रूप में उदाहरण दर्ज करें और जहाँ भी आपको ज़रूरत हो उसे इंजेक्ट करें - मैं यहाँ ऑटोफेक कंटेनर का उपयोग करता हूँ आप इसे कैसे करते हैं:

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

आप एमएस डिपेंडेंसी इंजेक्शन के साथ भी ऐसा कर सकते हैं:

services.AddSingleton<IConfigurationRoot>(appConfiguration);
— एलेक्स हरमन
स्रोत
6

यहाँ ASP.NET कोर के लिए पूर्ण उपयोग मामला है!

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" कौन सा संस्करण है?
— स्टीव स्मिथ
5

वे बस चीजों को बदलते रहते हैं - सिर्फ विजुअल स्टूडियो को अपडेट करने और वसूली के लिए सड़क पर पूरे प्रोजेक्ट बम, और नया तरीका इस तरह दिखता है:

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)
— Monolithcode
स्रोत
1
एक ही दृष्टिकोण का उपयोग करके हम टेस्ट प्रोजेक्ट्स में ऐपसेटिंग मूल्यों को कैसे प्राप्त कर सकते हैं?
— एस। शिवा
2
They just keep changing things। यह। इस पृष्ठ पर लगभग हर उत्तर केवल .Net कोर के एक विशिष्ट संस्करण पर लागू होता है।
— स्टीव स्मिथ
4

.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 फ़ाइल पर राइट-क्लिक करें - गुण पर क्लिक करें -> यदि नया है तो कॉपी का चयन करें: यहां छवि विवरण दर्ज करें

  1. अंत में, आप कर सकते हैं:

    config [ "कुंजी 1"]

यह देखते हुए कि मेरी कॉन्फ़िगरेशन फ़ाइल इस तरह दिखाई देगी:

{
    "ConnectionStrings": "myconnection string here",
    "key1": "value here"
}
— ग्रेगरी
स्रोत
2

आप नीचे दिए गए कोड की कोशिश कर सकते हैं। यह मेरे लिए काम कर रहा है।

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);
    }
}
— जीशान सिद्दीक
स्रोत
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 प्रोजेक्ट बनाते हैं, तो आपके पास निम्नलिखित कॉन्फ़िगरेशन लाइन होगी 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();
    }
}
— Ogglas
स्रोत
@ ऑग्लास ... वेदरफोर्स्टकंट्रोलर () का कॉलर कैसे प्राप्त कर सकता है जो IConfiguration को लागू करता है?
— जॉनी वू
1

क्या यह "धोखा" था? मैंने अभी-अभी स्टार्टअप क्लास स्टेटिक में अपना कॉन्फ़िगरेशन बनाया है, और फिर मैं इसे कहीं और से एक्सेस कर सकता हूं:

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; }
— ब्रायन मूर
स्रोत
1

कॉल के माध्यम से इसे ऑब्जेक्ट के रूप में कंट्रोलर के अंदर प्राप्त करें Get<YourType>():

public IActionResult Index([FromServices] IConfiguration config)
{
    BillModel model = config.GetSection("Yst.Requisites").Get<BillModel>();
    return View(model);
}
— लापेनकोव व्लादिमीर
स्रोत
1

पहले आपको IConfiguration को इंजेक्ट करना चाहिए और फिर एपसेटिंग से पढ़ने के लिए, आप इनमें से किसी एक विधि का उपयोग कर सकते हैं:

  1. एक अनुभाग डेटा प्राप्त करें

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

  2. एक अनुभाग के भीतर एक मूल्य प्राप्त करें

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

  3. अनुभाग में नेस्टेड मान प्राप्त करें

    var redisExpireMInutes = configuration.GetValue<int>("RedisConfig:ServerName:ExpireMInutes");
— नामी नेमेई
स्रोत
नियंत्रकों के लिए इंजेक्शन का काम करता है, लेकिन क्या होगा अगर मैं इसे यहां जैसे मिडलवेयर में उपयोग करना चाहता हूं ? ईजी मैं HTTP प्रतिक्रियाओं को कैश करने के लिए मिडलवेयर के रूप में रेडिस का उपयोग कर रहा हूं।
— अलेक्जेंडर रयान बैगेट ने 19
1

.NET कोर 2.2 तरीका

(इसमें कोई शक नहीं कि Microsoft इसे अगले .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 स्टार्टअप

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;
    }
— user1321471
स्रोत
0

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

मैंने विशेष रूप से इसे बनाया है ताकि मैं अपने डॉटनेट कंसोल एप्लिकेशन में एक ऐपकानफिग.जॉन का उपयोग कर सकूं। मैंने इसे अपने Program.Mainकार्य में लगाया :

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

और यह dynamicसंपत्ति के लिए एक वस्तु वापस कर देगा । (एक JsonElement अगर यह एक आदिम नहीं है)। मेरी appsettings.jsonफ़ाइल इस तरह दिखती है:

{
  "Environment": {
    "Token": "abc-123",
    "Name": "Production"
  }
}
— जस्टिन गिलमैन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.