Asp.net कोर में dev और रिलीज़ वातावरण के लिए appsettings.json को स्वचालित रूप से सेट करें?

Question

मैंने अपने appsettings.jsonलिए कुछ मानों को परिभाषित किया है जैसे कि डेटाबेस कनेक्शन स्ट्रिंग्स, वेबापी स्थान और जैसे जो विकास, मंचन और लाइव वातावरण के लिए भिन्न हैं।

वहाँ कई appsettings.jsonफ़ाइलों (जैसे appsettings.live.json, आदि) के लिए एक रास्ता है और asp.net app सिर्फ 'पता है' जो एक का उपयोग करने के लिए यह चल रहा है कि निर्माण विन्यास के आधार पर है?

Answer 1

आप सशर्त संकलन का उपयोग कर सकते हैं:

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
    .SetBasePath(env.ContentRootPath)
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
#if SOME_BUILD_FLAG_A
    .AddJsonFile($"appsettings.flag_a.json", optional: true)
#else
    .AddJsonFile($"appsettings.no_flag_a.json", optional: true)
#endif
    .AddEnvironmentVariables();
    this.configuration = builder.Build();
}

Comments

आपको अपने परिवेश चर को अपने MSBuild / TFS बिल्ड में सेट करना चाहिए। सशर्त संकलन सीआई बिल्ड में आसानी से संभाला हुआ कुछ के लिए गलतियों की ओर जाता है। यानी, .AddJsonFile ($ "appettings। {Env.EnvironmentName} .json", वैकल्पिक: सत्य)

— निक टर्नर

पर्यावरण चर के लिए मेरा उत्तर देखें ( stackoverflow.com/a/50331886/1319086 )

— जोनाथन ड्रैगन

इस तरह का दृष्टिकोण कोड को प्रत्येक वातावरण के लिए विशेष रूप से पुन: संकलित करने के लिए मजबूर करता है, जिससे इसे कहीं और पुनर्वितरित / स्थापित करना असंभव हो जाता है।

— tvdias

प्रश्न "बिल्ड कॉन्फ़िगरेशन के बारे में जानना" के बारे में था

— दिमित्री

इसे स्वीकृत उत्तर के रूप में चिह्नित नहीं किया जाना चाहिए - हालांकि यह एक समाधान है जो सबसे अच्छा अभ्यास नहीं है।

— चारलेह

Answer 2

मैंने एक काम के माहौल के स्क्रीनशॉट को जोड़ा है, क्योंकि इसमें मुझे कई घंटे आरएंडडी की लागत है।

1. सबसे पहले, अपनी launch.jsonफ़ाइल में एक कुंजी जोड़ें ।

   नीचे स्क्रीनशॉट देखें, मैंने Developmentअपने वातावरण के रूप में जोड़ा है।

   

2. फिर, अपने प्रोजेक्ट में, एक नई appsettings.{environment}.jsonफ़ाइल बनाएं जिसमें पर्यावरण का नाम शामिल हो।

   निम्नलिखित स्क्रीनशॉट में, नामों के साथ दो अलग-अलग फ़ाइलों को देखें:

   • appsettings.Development.Json
   • appSetting.json

   
   

3. और अंत में, इसे अपनी StartUpकक्षा में इस तरह कॉन्फ़िगर करें:

   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();
   
       Configuration = builder.Build();
   }
   

4. और अंत में, आप इसे कमांड लाइन से इस तरह से चला सकते हैं:

   dotnet run --environment "Development"
   

   जहां "Development"मेरी पर्यावरण का नाम है।

Comments

कोशिश की और यह महान काम करता है। VS2017 भी आधार फ़ाइल के तहत विभिन्न संस्करणों को प्रदर्शित करता है। वोट देना।

— रॉबर्टो

आप इसे कोर 2.2 में कैसे कर सकते हैं क्योंकि ihostingenvironment खराब हो गया है

— djack109

@ djack109 आपको IWebHostEnvironmentइसके बजाय उपयोग करना चाहिए ।

— एलेसेंड्रोकार्ब

Answer 3

.NET Core 3.0+ के लिए अपडेट करें

1. आप उपयोग कर सकते हैं CreateDefaultBuilderजो स्वचालित रूप से आपके स्टार्टअप वर्ग में एक कॉन्फ़िगरेशन ऑब्जेक्ट का निर्माण और पारित करेगा:

   WebHost.CreateDefaultBuilder(args).UseStartup<Startup>();
   

   public class Startup
   {
       public Startup(IConfiguration configuration) // automatically injected
       {
           Configuration = configuration;
       }
       public IConfiguration Configuration { get; }
       /* ... */
   }
   

2. CreateDefaultBuilderस्वचालित रूप से उपयुक्त फ़ाइल शामिल है इसलिए प्रत्येक वातावरण के लिए एक अलग एप्लेटिंग फ़ाइल जोड़ें:appsettings.Environment.json

   

3. फिर चल रहा / डिबगिंग करते समय ASPNETCORE_ENVIRONMENT पर्यावरण चर सेट करें

पर्यावरण चर सेट कैसे करें

आपकी IDE के आधार पर, कुछ स्थान हैं जहाँ इंटरनेट की पारंपरिक चर के लिए डॉटनेट परियोजनाएँ दिखती हैं:

• के लिए दृश्य स्टूडियो परियोजना> गुण> डीबग> पर्यावरण चर पर जाएँ:

  

• के लिए दृश्य स्टूडियो कोड , संपादित करें .vscode/launch.json> env:

  

• लॉन्च सेटिंग्स का उपयोग करना , संपादित करें Properties/launchSettings.json> environmentVariables:

  

  जिसे विजुअल स्टूडियो में टूलबार से भी चुना जा सकता है

  

• डॉटनेट सीएलआई का उपयोग करते हुए , अपने ओएस के अनुसार पर्यावरण चर सेट करने के लिए उपयुक्त सिंटैक्स का उपयोग करें

  नोट : जब एक ऐप को डॉटनेट रन के साथ लॉन्च किया जाता है , launchSettings.jsonतो उपलब्ध होने पर पढ़ा जाता है, और environmentVariablesलॉन्च में सेटिंग। सेटिंग। पर्यावरण वेरिएबल्स को ओवरराइड करता है।

कैसे Host.CreateDefaultBuilder काम ?

.NET कोर 3.0 Host.CreateDefaultBuilderको प्लेटफ़ॉर्म एक्सटेंशन के तहत जोड़ा गया है जो एक डिफ़ॉल्ट आरंभीकरण प्रदान करेगा, IConfigurationजो निम्नलिखित क्रम में ऐप के लिए डिफ़ॉल्ट कॉन्फ़िगरेशन प्रदान करता है:

1. appsettings.jsonJSON कॉन्फ़िगरेशन प्रदाता का उपयोग करना ।
2. appsettings.Environment.jsonJSON कॉन्फ़िगरेशन प्रदाता का उपयोग करना । उदाहरण के लिए:
   • appsettings.Production.json या
   • appsettings.Development.json
3. अनुप्रयोग रहस्यजब ऐप डेवलपमेंट के माहौल में चलता है तो ।
4. पर्यावरण चर, पर्यावरण चर विन्यास प्रदाता का उपयोग करते हुए ।
5. कमांड लाइन कॉन्फ़िगरेशन प्रदाता का उपयोग करके कमांड-लाइन तर्क ।

इसके अलावा पढ़ना - एमएस डॉक्स

• ASP.NET कोर में ऐप स्टार्टअप
• ASP.NET कोर में कॉन्फ़िगरेशन
• ASP.NET कोर में कई वातावरण का उपयोग करें

Comments

धन्यवाद, यह अच्छा है लेकिन कंसोल प्रक्रिया (या कार्यकर्ता प्रक्रिया टेम्पलेट / मचान) के साथ ऐसा कैसे करें?

— hB0

यह नवीनतम संस्करण के साथ काम नहीं करता है, यह हमेशा appsettings.json ले जाएगा और appsettings.development.json को अनदेखा करेगा। रन (देव) और रन (ठेस) भी गायब है।

— user1034912

Answer 4

ASP.NET Core में आपको उचित appsettings.json के लिए बिल्ड कॉन्फ़िगरेशन के बजाय पर्यावरण चर का उपयोग करना चाहिए

1. आप प्रोजेक्ट> गुण> डीबग> पर्यावरण चर पर राइट क्लिक करें

   

2. ASP.NET कोर उपयुक्त appsettings.json फ़ाइल का उपयोग करेगा:

   

3. अब आप इस तरह पर्यावरण चर का उपयोग कर सकते हैं:

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

नोट : यदि आप @ दिमित्री के उत्तर का उपयोग करते हैं , तो आप समस्याओं में भाग सकते हैं। जब Azure पर appsettings.json मूल्यों को ओवरराइड करते हैं ।

Answer 5

आप इस तरह के निर्माण ConfigurationBuilderमें पर्यावरण चर और वर्ग का उपयोग कर सकते हैं Startup:

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();
    this.configuration = builder.Build();
}

फिर आप appsettings.xxx.jsonअपनी जरूरत के हर वातावरण के लिए एक फाइल बनाते हैं , जिसमें "xxx" पर्यावरण का नाम है। ध्यान दें कि आप अपनी "सामान्य" appsettings.jsonफ़ाइल में सभी वैश्विक कॉन्फ़िगरेशन मान रख सकते हैं और केवल इन नई फ़ाइलों में पर्यावरण विशिष्ट सामग्री डाल सकते हैं।

अब आपको केवल ASPNETCORE_ENVIRONMENTकुछ विशिष्ट पर्यावरण मूल्य ("लाइव", "स्टेजिंग", "उत्पादन", जो भी) के साथ एक पर्यावरण चर की आवश्यकता है । आप अपने विकास के वातावरण के लिए अपनी परियोजना सेटिंग्स में इस चर को निर्दिष्ट कर सकते हैं, और निश्चित रूप से आपको इसे अपने मंचन और उत्पादन वातावरण में भी सेट करने की आवश्यकता है। जिस तरह से आप इसे करते हैं वह इस बात पर निर्भर करता है कि यह किस तरह का वातावरण है।

अद्यतन: मुझे अभी पता चला है कि आप appsettings.xxx.jsonअपने वर्तमान बिल्ड कॉन्फ़िगरेशन के आधार पर चयन करना चाहते हैं । यह मेरे प्रस्तावित समाधान से हासिल नहीं किया जा सकता है और मुझे नहीं पता कि क्या ऐसा करने का कोई तरीका है। "पर्यावरण चर" तरीका, हालांकि, काम करता है और आपके दृष्टिकोण के लिए एक अच्छा विकल्प हो सकता है।

Comments

मैंने परियोजना के गुण-> डिबग सेक्शन में पर्यावरण चर का उपयोग करते हुए देखा, हालांकि कोई स्पष्ट तरीका नहीं है कि यह प्रोजेक्ट सेटिंग्स के आधार पर कैसे बदलेगा। क्या वह दूसरी फाइल है जिसे मैं अपने प्रोजेक्ट में जोड़ सकता हूं?

— मेड

प्रोजेक्ट प्रॉपर्टीज़ के भीतर वैरिएबल सेट करना केवल आपके विकास के वातावरण (शायद विजुअल स्टूडियो) में इसका उपयोग करने के लिए काम करेगा। आपको विशिष्ट वातावरण (IIS, Azure) के आधार पर अपने तैनात किए गए ऐप्स के लिए इसे कहीं और सेट करना होगा। मैं कुछ कॉन्फ़िगरेशन फ़ाइल में चर सेट करने की अनुशंसा नहीं करूंगा क्योंकि यह फ़ाइल तैनात हो सकती है, भी, और फिर सर्वर मान को ओवरराइड कर सकती है।

— ओन्केल टोब

आप इसे बिल्ड कॉन्फ़िगरेशन में सेट करें। यदि कोई बिल्ड कॉन्फ़िगरेशन फ़ाइल नहीं है, तो वे इसे मैन्युअल रूप से कर रहे हैं, इसलिए उन्हें इसे (पुरातन) परिनियोजन प्रोफ़ाइल में सेट करने की आवश्यकता होगी

— निक टर्नर

मेरे पास एज़्योर में परीक्षण, मंचन और उत्पादन जैसे कई वातावरण हैं। अगर मैं वीएस से अज़ुरे तक वेब ऐप के रिलीज़ बिल्ड को प्रकाशित करना चाहता हूं, तो मैं ASPNETCORE_ENVIRONMENT चर को कहां बदलूं?

— ठंढा

हम परिनियोजन के दौरान चर नहीं बदलते हैं, इसके बजाय, वे विशिष्ट वातावरण में निर्मित होते हैं। Azure में, आप इन मूल्यों को सीधे अपने ऐप सेवा कॉन्फ़िगरेशन unter "Application settings" के भीतर सेट कर सकते हैं। यदि आप कई स्लॉट्स के साथ काम कर रहे हैं, तो उन्हें "परिनियोजन स्लॉट सेटिंग" के रूप में चिह्नित करना न भूलें।

— ओनकेल टोब

Answer 6

.NET कोर 2.0 उपयोगकर्ताओं के लिए बस एक अपडेट, आप कॉल के बाद एप्लिकेशन कॉन्फ़िगरेशन निर्दिष्ट कर सकते हैं CreateDefaultBuilder:

public class Program
{
   public static void Main(string[] args)
   {
      BuildWebHost(args).Run();
   }

   public static IWebHost BuildWebHost(string[] args) =>
      WebHost.CreateDefaultBuilder(args)
             .ConfigureAppConfiguration(ConfigConfiguration)
             .UseStartup<Startup>()
             .Build();

   static void ConfigConfiguration(WebHostBuilderContext ctx, IConfigurationBuilder config)
   {
            config.SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("config.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"config.{ctx.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);

   }
 }

Comments

आप उपयोग किए जा रहे वातावरण के बीच कैसे स्विच करते हैं? क्या किसी भी कॉन्फिगर फाइल में बदलाव किए जाने चाहिए? मैं समझता हूं कि मुझे उस URL को जोड़ना होगा जिसका उपयोग मैं तब करना चाहता हूं जब परियोजना Azure पर appsettings.json पर चलती है और जिस URL को मैं स्थानीय रूप से (F5 द्वारा) चलाने के लिए appsettings.Development.json में निष्पादित करना चाहता हूं । क्या वो सही है? मेरा स्ट्रिंग जो मैं उपयोग करना चाहता हूं वह फ़ाइल launchSettings.json में है और मैं थोड़ा अस्पष्ट हूं कि इसे कैसे बदला जाए जहां आवेदन निष्पादित किया गया है (या यदि इसे बिल्कुल बदल दिया जाए)।

— गधाबनाणा

@DonkeyBanana पर्यावरण परियोजना गुणों में निर्दिष्ट सेटिंग से अधिक कुछ नहीं है। वीएस 2017 में, प्रोजेक्ट> संपत्तियों पर राइट क्लिक करें। डीबग के तहत, आपको कुंजी के लिए वर्तमान परिवेश दिखाई देगा ASPNETCORE_ENVIRONMENT। मान वह है जो के लिए प्रतिस्थापित किया जाएगा ctx.HostingEnvironment.EnvironmentName}। इसलिए यदि आप उस मूल्य को 'प्रोडक्शन' में सेट करते हैं, तो प्रोजेक्ट config.Production.jsonरूट फ़ोल्डर में फाइल की तलाश करेगा । अधिक जानकारी के लिए, कृपया इस लिंक को देखें

— umutesen

Error CS0266 Cannot implicitly convert type 'Microsoft.AspNetCore.Hosting.IWebHost' to 'Microsoft.AspNetCore.Hosting.IWebHostBuilder'. An explicit conversion exists (are you missing a cast?) WebHost.CreateDefaultBuiler में एक बनाता है (...

— Hecatonchires

यह ध्यान देने योग्य है कि यहां यह कहा गया है कि "AddJsonFile को स्वचालित रूप से दो बार कॉल किया जाता है जब आप CreateDefaultBuilder के साथ एक नया होस्ट बिल्डर को इनिशियलाइज़ करते हैं"। दूसरे शब्दों में, यह पहले से ही appSettings.json लोड कर रहा है और फिर आपके पर्यावरण कॉन्फ़िगरेशन के आधार पर, यह appsettings लोड कर रहा है। {पर्यावरण}} .json

— डेविड येट्स

@umutsen नवीनतम दृश्य स्टूडियो में कोई और अधिक पर्यावरण सेटिंग नहीं है

— user1034912

Answer 7

1. कई फाइलें बनाएं जैसे:appSettings.$(Configuration).json

   • appSettings.staging.json
   • appSettings.production.json

2. प्रोजेक्ट पर एक पूर्व-बिल्ड ईवेंट बनाएं, जो संबंधित फ़ाइल को यहां कॉपी करता है appSettings.json:

   copy appSettings.$(Configuration).json appSettings.json
   

3. केवल appSettings.jsonअपने कॉन्फ़िगरेशन बिल्डर में उपयोग करें :

   var builder = new ConfigurationBuilder()
               .SetBasePath(env.ContentRootPath)
               .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
               .AddEnvironmentVariables();
   
   Configuration = builder.Build();
   

Comments

यह एक स्वीकृत उत्तर होना चाहिए। जटिल मामलों के लिए SlowCheetah का उपयोग किया जा सकता है।

— एंटोन क्राउग्लोव

Answer 8

आप नीचे ASPNETCORE_ENVIRONMENTके launchSettings.jsonरूप में कॉन्फ़िगरेशन नाम जोड़ सकते हैं

  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:58446/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "environmentVariables": {
        ASPNETCORE_ENVIRONMENT": "$(Configuration)"
      }
    }
  }

Answer 9

यह वह संस्करण है जो वेब पेज के बिना कंसोल ऐप का उपयोग करते समय मेरे लिए काम करता है:

var builder = new ConfigurationBuilder()
             .SetBasePath(Directory.GetCurrentDirectory())
             .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
             .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json", optional: true);

            IConfigurationRoot configuration = builder.Build();
            AppSettings appSettings = new AppSettings();
            configuration.GetSection("AppSettings").Bind(appSettings);

Answer 10

.vscode / launch.json फ़ाइल केवल Visual Studio द्वारा / साथ ही /Properties/launchSettings.son फ़ाइल का उपयोग किया जाता है। उत्पादन में इन फ़ाइलों का उपयोग न करें।

लॉन्चसैटिंग.जसन फ़ाइल:

1. का उपयोग केवल स्थानीय विकास मशीन पर किया जाता है।
2. तैनात नहीं है।

3. प्रोफ़ाइल सेटिंग्स शामिल हैं।

   • प्रक्षेपण में पर्यावरण के मान सेट किए गए हैं। सिस्टम वातावरण में सेट किए गए मान को ओवरराइड करते हैं

उदाहरण के लिए एक फ़ाइल 'appSettings.QA.json' का उपयोग करने के लिए। आप 'ASPNETCORE_ENVIRONMENT' का उपयोग कर सकते हैं। नीचे दिए गए चरणों का पालन करें।

1. होस्ट मशीन पर एक नया पर्यावरण चर जोड़ें और इसे 'ASPNETCORE_ENVIRONMENT' कहें। इसके मूल्य को 'QA' पर सेट करें।
2. अपनी परियोजना में एक फ़ाइल 'appSettings.QA.json' बनाएँ। यहां अपना कॉन्फ़िगरेशन जोड़ें।
3. चरण 1 में मशीन को नियुक्त करें। 'appSettings.QA.json' की पुष्टि करें।
4. अपनी वेबसाइट लोड करें। AppSettings.QA.json की अपेक्षा यहाँ करें।