App.config / web.config के भीतर चर


92

क्या यह संभव है कि निम्नलिखित app.configया web.configफाइलों में कुछ ऐसा किया जाए ?

<appSettings>
 <add key="MyBaseDir" value="C:\MyBase" />
 <add key="Dir1" value="[MyBaseDir]\Dir1"/>
 <add key="Dir2" value="[MyBaseDir]\Dir2"/>
</appSettings>

मैं फिर अपने कोड में Dir2 को केवल कह कर एक्सेस करना चाहता हूं:

 ConfigurationManager.AppSettings["Dir2"]

जब मैं अपने एप्लिकेशन को विभिन्न सर्वरों और स्थानों में स्थापित करता हूं, तो मुझे इसमें मदद मिलेगी, जिसमें मुझे केवल एक प्रविष्टि को अपने संपूर्ण में बदलना होगा app.config। (मुझे पता है कि मैं कोड में सभी सहमति का प्रबंधन कर सकता हूं, लेकिन मैं इसे इस तरह से पसंद करता हूं)।


मुझे लगता है कि वह सीधे विन्यास फाइल के भीतर appSettings कुंजी में उपयोग करने के लिए चर को परिभाषित करने के बारे में बात कर रहा है।
मिशैल कारपेंटियर

1
मैंने XML <! ENTITY> घोषणा का उपयोग करके भी जांच की है, लेकिन इसका उस तरह से समर्थन नहीं किया गया है जिस तरह से MS web.config फ़ाइलों को संभालता है।
चिल्टपम्प

आपके प्रयासों के लिए धन्यवाद। मैं किसी भी कोड को संशोधित नहीं करना पसंद करता हूं। कोड में पहले से ही एक कथन है: string dir2 = configurationManager.AppSettings ["Dir2"]। मैं केवल app.config को साफ करना चाहता हूं, जो अब मूल्य = "D: \ blahdir \ Dir2" कहता है मान के बजाय = "[MyBaseDir] \ Dir2"
DeeStackOverflow

जवाबों:


7

अच्छा प्रश्न।

मुझे नहीं लगता कि वहाँ है। मेरा मानना ​​है कि अगर यह एक आसान तरीका होता, तो यह बहुत अच्छी तरह से ज्ञात होता, और मैं देख रहा हूं कि Microsoft परिनियोजन और परीक्षण के लिए अलग-अलग कॉन्फ़िगरेशन फ़ाइलों की तैनाती के लिए Visual Studio 2010 में एक तंत्र बना रहा है।

हालांकि, इसके साथ ही; मैंने पाया है कि आप ConnectionStringsअनुभाग में एक प्रकार का प्लेसहोल्डर है जिसका नाम है "| DataDirectory |"। शायद तुम वहाँ काम पर क्या है पर एक नज़र हो सकता है ...

यहाँ machine.configयह दिखाने से एक टुकड़ा है:

 <connectionStrings>
    <add
        name="LocalSqlServer"
        connectionString="data source=.\SQLEXPRESS;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|aspnetdb.mdf;User Instance=true"
        providerName="System.Data.SqlClient"
    />
 </connectionStrings>

यह रोचक जानकारी है। हो सकता है कि पाइप प्रतीक ("|") का उपयोग करके चर को एक्सेस किया जाए। हम्म .. मुझे आश्चर्य है कि अगर यह काम करेगा: <add key = "Dir2" value = "| MyBaseDAM। \ Dir2" />
DeeStackOverflow

4
DataDirectory मान वास्तव में AppDomain में डेटा तत्व है। आप AppDomain.CurrentDomain.SetData ("DataDirectory", dataPath) का उपयोग करके मान को ओवरराइड कर सकते हैं; मैंने परीक्षण नहीं किया है यदि आप इस तरह के अन्य चर को परिभाषित कर सकते हैं और उन्हें "ऑटोफैक्स्ड" प्राप्त कर सकते हैं ...
पीटर लिलेवॉल्ड

22

थोड़ा और अधिक जटिल, लेकिन कहीं अधिक लचीला, वैकल्पिक एक वर्ग बनाने के लिए है जो एक कॉन्फ़िगरेशन अनुभाग का प्रतिनिधित्व करता है। आपकी app.config/ web.configफ़ाइल में, आपके पास यह हो सकता है:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <!-- This section must be the first section within the <configuration> node -->
    <configSections>
        <section name="DirectoryInfo" type="MyProjectNamespace.DirectoryInfoConfigSection, MyProjectAssemblyName" />
    </configSections>

    <DirectoryInfo>
        <Directory MyBaseDir="C:\MyBase" Dir1="Dir1" Dir2="Dir2" />
    </DirectoryInfo>
</configuration>

फिर, आपके .NET कोड में (मैं अपने उदाहरण में C # का उपयोग करूंगा), आप इस तरह दो कक्षाएं बना सकते हैं:

using System;
using System.Configuration;

namespace MyProjectNamespace {

    public class DirectoryInfoConfigSection : ConfigurationSection {

        [ConfigurationProperty("Directory")]
        public DirectoryConfigElement Directory {
            get {
                return (DirectoryConfigElement)base["Directory"];
            }
    }

    public class DirectoryConfigElement : ConfigurationElement {

        [ConfigurationProperty("MyBaseDir")]
        public String BaseDirectory {
            get {
                return (String)base["MyBaseDir"];
            }
        }

        [ConfigurationProperty("Dir1")]
        public String Directory1 {
            get {
                return (String)base["Dir1"];
            }
        }

        [ConfigurationProperty("Dir2")]
        public String Directory2 {
            get {
                return (String)base["Dir2"];
            }
        }
        // You can make custom properties to combine your directory names.
        public String Directory1Resolved {
            get {
                return System.IO.Path.Combine(BaseDirectory, Directory1);
            }
        }
    }
}

अंत में, अपने प्रोग्राम कोड में, आप अपने app.configचर का उपयोग कर सकते हैं, इस तरह से अपनी नई कक्षाओं का उपयोग कर सकते हैं:

DirectoryInfoConfigSection config =
  (DirectoryInfoConfigSection)ConfigurationManager.GetSection("DirectoryInfo");
String dir1Path = config.Directory.Directory1Resolved;  // This value will equal "C:\MyBase\Dir1"

1
धन्यवाद, लेकिन मैं किसी भी कोड को संशोधित किए बिना ऐसा करने की कोशिश कर रहा हूं क्योंकि यह इस स्तर पर एक दर्द है।
डेस्टेकऑवरफ्लो

कोड की अंतिम पंक्ति (गिनती गिनना नहीं) में एक छोटी सी त्रुटि है: "System.IO.Path.Combine (MyBaseDir, Dir1) लौटें;" इसके बजाय "वापसी System.IO.Path.Combine (BaseDirectory, Dir1)?" होना चाहिए, या अन्यथा विधि को 'आधार निर्देशिका' से 'MyBaseDir' में बदला जाना चाहिए
TheWho

16

आप मेरे पुस्तकालय विस्तारक का उपयोग करके पूरा कर सकते हैं । इसके अलावा यहाँ पर उपलब्ध है

इसे प्राथमिक उपयोग के मामले के रूप में तैयार किया गया था।

मध्यम उदाहरण (टोकन विस्तार के लिए डिफ़ॉल्ट स्रोत के रूप में AppSettings का उपयोग करके)

App.config में:

<configuration>
    <appSettings>
        <add key="Domain" value="mycompany.com"/>
        <add key="ServerName" value="db01.{Domain}"/>
    </appSettings>
    <connectionStrings>
        <add name="Default" connectionString="server={ServerName};uid=uid;pwd=pwd;Initial Catalog=master;" provider="System.Data.SqlClient" />
    </connectionStrings>
</configuration>

विस्तारित किए जाने वाले स्ट्रिंग पर .Expand () एक्सटेंशन विधि का उपयोग करें :

var connectionString = ConfigurationManager.ConnectionStrings["Default"].ConnectionString;
connectionString.Expand() // returns "server=db01.mycompany.com;uid=uid;pwd=pwd;Initial Catalog=master;"

या

डायनामिक कॉन्फ़िगरेशन प्रबंधक रैपर "कॉन्फ़िगरेशन" का उपयोग इस प्रकार करें (स्पष्ट कॉल टू एक्सपेंशन (आवश्यक नहीं)):

var serverName = Config.AppSettings.ServerName;
// returns "db01.mycompany.com"

var connectionString = Config.ConnectionStrings.Default;
// returns "server=db01.mycompany.com;uid=uid;pwd=pwd;Initial Catalog=master;"

उन्नत उदाहरण 1 (टोकन विस्तार के लिए डिफ़ॉल्ट स्रोत के रूप में AppSettings का उपयोग करके)

App.config में:

<configuration>
    <appSettings>
        <add key="Environment" value="dev"/>
        <add key="Domain" value="mycompany.com"/>
        <add key="UserId" value="uid"/>
        <add key="Password" value="pwd"/>
        <add key="ServerName" value="db01-{Environment}.{Domain}"/>
        <add key="ReportPath" value="\\{ServerName}\SomeFileShare"/>
    </appSettings>
    <connectionStrings>
        <add name="Default" connectionString="server={ServerName};uid={UserId};pwd={Password};Initial Catalog=master;" provider="System.Data.SqlClient" />
    </connectionStrings>
</configuration>

विस्तारित किए जाने वाले स्ट्रिंग पर .Expand () एक्सटेंशन विधि का उपयोग करें:

var connectionString = ConfigurationManager.ConnectionStrings["Default"].ConnectionString;
connectionString.Expand() // returns "server=db01-dev.mycompany.com;uid=uid;pwd=pwd;Initial Catalog=master;"

4
मुझे लगता है कि यह उत्तर बहुत मूल्यांकन के तहत है !!
अहमद

धन्यवाद अहमद! मुझे पता है कि आप कैसे प्रशस्त पसंद करते हैं।
anderly

हालाँकि यह ऐप सेटिंग्स का रनटाइम 'रिज़ॉल्यूशन' है, लेकिन यह रिपीटिटिव की-वैल्यू पेयर होने के मेरे मुद्दों को हल करता है। हमने इसका उपयोग करके अपने विन्यास रखरखाव को महत्वपूर्ण रूप से कम कर दिया है। यहाँ निरपेक्ष यूटोपिया यह होगा कि यह स्लो टाइमशीट के साथ काम करने के लिए बिल्ड टाइम प्लगइन हो। अगर मैं कर सकता तो मैं फिर से +1 करता। महान सामान और।
अहमद

क्या आप कृपया इसका संक्षिप्त उदाहरण प्रदान कर सकते हैं कि आपके पुस्तकालय को इसे पूरा करने के लिए कैसे इस्तेमाल किया जा सकता है?
रयान गेट्स

किसी और के लिए बस अब इस पर ठोकर खाते हुए, इस परियोजना को अब 6 साल हो गए हैं, 2011 से:
user1003916

4

मुझे लगा कि मैंने अभी यह प्रश्न देखा है।

संक्षेप में, नहीं, कोई एप्लिकेशन कॉन्फ़िगरेशन के भीतर कोई चर प्रक्षेप नहीं है।

आपके पास दो विकल्प हैं

  1. आप रनटाइम पर अपने खुद के स्थानापन्न चर को रोल कर सकते हैं
  2. निर्माण के समय, लक्ष्य परिनियोजन वातावरण की विशेष बारीकियों के लिए एप्लिकेशन कॉन्फ़िगरेशन की मालिश करें। विन्यास-दुःस्वप्न से निपटने पर इस पर कुछ विवरण

यह सही पोस्ट है। मेरी पिछली पोस्ट (एक ही सवाल) ने app.config xml प्रविष्टि उदाहरण नहीं दिखाया। मैंने आपके लिंक की जांच की - यह बहुत अधिक काम है और वहां समय नहीं बिताना पसंद करते हैं। हमारे पास अलग-अलग बॉक्स के लिए अलग-अलग ऐप हैं। मैं उससे दूर जाना चाहता हूं।
डेस्टेकऑवरफ्लो

3

आपके पास विकल्पों की एक जोड़ी है। आप इसे एक बिल्ड / परिनियोजित चरण के साथ कर सकते हैं जो आपके कॉन्फ़िगरेशन फ़ाइल को सही मान के साथ आपके चर की जगह ले लेगा।

एक अन्य विकल्प आपके स्वयं के कॉन्फ़िगरेशन अनुभाग को परिभाषित करना होगा जिसने इस का समर्थन किया। उदाहरण के लिए इस xml की कल्पना करें:

<variableAppSettings>
 <variables>
    <add key="@BaseDir" value="c:\Programs\Widget"/>
 </variables>
 <appSettings>
    <add key="PathToDir" value="@BaseDir\Dir1"/>
 </appSettings>
</variableAppSettings>

अब आप इसे कस्टम कॉन्फ़िगरेशन ऑब्जेक्ट्स का उपयोग करके कार्यान्वित करेंगे जो रनटाइम में आपके लिए वेरिएबल्स को बदलने का काम करेंगे।


मुझे आपकी xml पोस्ट दिखाई नहीं दे रही है (xml टैग पोस्ट करने में सक्षम होने के लिए अपनी लाइन 5 वर्णों को इंडेंट करें - मुझे हर बार यही समस्या थी)। इसके अलावा, 'कस्टम कॉन्फ़िगरेशन ऑब्जेक्ट' क्या हैं? मैं इसे प्राप्त करने के लिए शून्य कोडिंग पसंद करता हूं क्योंकि इस स्तर पर कोडिंग परिवर्तन हमें बहुत पीछे छोड़ देगा।
डेस्टेकऑवरफ्लो

कस्टम कॉन्फ़िगरेशन में निश्चित रूप से [सरल] कोडिंग शामिल है। लेकिन IMHO यह हमेशा तुम्हारा सबसे अच्छा विकल्प है। मैं लगभग कभी भी ऐपसेटिंग का उपयोग नहीं करता, इसके बजाय हर प्रोजेक्ट के लिए एक कस्टम कॉन्फिगर बनाना पसंद करता हूं।
पोर्टमैन

3

औपचारिक रूप से, मैं अपने web.config की प्रत्येक सेटिंग का उपयोग करने के लिए गुणों के साथ एक स्थिर वर्ग लिखना समाप्त करता हूं।

public static class ConfigManager 
{
    public static string MyBaseDir
    {
        return ConfigurationManager.AppSettings["MyBaseDir"].toString();
    }

    public static string Dir1
    {
        return MyBaseDir + ConfigurationManager.AppSettings["Dir1"].toString();
    }

}

आमतौर पर, मैं इस वर्ग में आवश्यक रूप से रूपांतरण भी करता हूं। यह आपके कॉन्‍फ़‍िगर करने के लिए टाइप की गई पहुंच की अनुमति देता है, और यदि सेटिंग बदल जाती है, तो आप उन्हें केवल एक ही स्थान पर संपादित कर सकते हैं।

आमतौर पर, इस वर्ग के साथ सेटिंग्स को बदलना अपेक्षाकृत आसान होता है और यह बहुत अधिक स्थिरता प्रदान करता है।


3

आपके app.configद्वारा वर्णित परिदृश्य के लिए आप अपने वातावरण में चर का उपयोग कर सकते हैं

<configuration>
  <appSettings>
    <add key="Dir1" value="%MyBaseDir%\Dir1"/>
  </appSettings>
</configuration>

तब आप आसानी से रास्ता पा सकते हैं:

var pathFromConfig = ConfigurationManager.AppSettings["Dir1"];
var expandedPath = Environment.ExpandEnvironmentVariables(pathFromConfig);

2

अंदर <appSettings>आप अनुप्रयोग कुंजी बना सकते हैं,

<add key="KeyName" value="Keyvalue"/>

बाद में आप इन मूल्यों का उपयोग कर सकते हैं:

ConfigurationManager.AppSettings["Keyname"]

विन्यास
प्रबंधक

2
संकेत सही है लेकिन पूछे गए प्रश्न का उत्तर नहीं है।
माइकेल कारपेयर

1

मैं आपको DslConfig का सुझाव दूंगा । DslConfig के साथ आप ग्लोबल कॉन्फिगर से पदानुक्रमित कॉन्फिग फाइलों का उपयोग कर सकते हैं, प्रत्येक सर्वर होस्ट पर प्रति एप्लिकेशन कॉन्फिगर करने के लिए प्रति सर्वर होस्ट को कॉन्फ़िगर करें (AppSpike देखें)।
यदि यह आपके लिए जटिल है, तो आप केवल वैश्विक कॉन्‍फ़िगरेशन का उपयोग कर सकते हैं Variables.var
बस Varibales.var में कॉन्फ़िगर करें

baseDir = "C:\MyBase"
Var["MyBaseDir"] = baseDir
Var["Dir1"] = baseDir + "\Dir1"
Var["Dir2"] = baseDir + "\Dir2"

और विन्यास मूल्यों के साथ मिलता है

Configuration config = new DslConfig.BooDslConfiguration()
config.GetVariable<string>("MyBaseDir")
config.GetVariable<string>("Dir1")
config.GetVariable<string>("Dir2")

0

मुझे नहीं लगता कि आप कॉन्फ़िगरेशन फ़ाइल के भीतर ऐपसेटिंग कुंजी को परिभाषित करने के लिए चर घोषित और उपयोग कर सकते हैं। मैंने आपके जैसे कोड में हमेशा कॉन्सेप्ट को प्रबंधित किया है।


0

मैं थोड़ा सा संघर्ष कर रहा हूं कि आप क्या चाहते हैं, लेकिन आप ऐप सेटिंग्स में एक ओवरराइड फ़ाइल जोड़ सकते हैं, फिर उस ओवरराइड फ़ाइल को प्रति पर्यावरण के आधार पर सेट कर सकते हैं।

<appSettings file="..\OverrideSettings.config">

0

उत्पादों को रोल आउट करने के लिए जहां हमें समान मूल्यों के साथ बहुत सी वस्तुओं को कॉन्फ़िगर करने की आवश्यकता होती है, हम छोटे कंसोल एप्लिकेशन का उपयोग करते हैं जो XML को पढ़ते हैं और पास किए गए मापदंडों के आधार पर अपडेट करते हैं। इसे तब इंस्टॉलर द्वारा कहा जाता है जब उसने उपयोगकर्ता से पूछा है। आवश्यक जानकारी।


0

मैं मैट हैस्मिथ के समाधान का पालन करने की सलाह दूंगा। यदि इसे लागू करने का कोई मुद्दा है, तो क्यों नहीं एक विस्तार विधि बनाई जाए जो इसे ऐपसेटिंग्स क्लास की पृष्ठभूमि में लागू करता है?

कुछ इस तरह:

    public static string GetValue(this NameValueCollection settings, string key)
    {

    }

लाइनक का उपयोग करके DictionaryInfoConfigSection के माध्यम से आपके द्वारा खोजे गए तरीके के अंदर और मिलान कुंजी के साथ मान लौटाएं। आपको इन पंक्तियों के साथ, विन्यास फाइल को अद्यतन करने की आवश्यकता होगी:

<appSettings>
  <DirectoryMappings>
    <DirectoryMap key="MyBaseDir" value="C:\MyBase" />
    <DirectoryMap key="Dir1" value="[MyBaseDir]\Dir1"/>
    <DirectoryMap key="Dir2" value="[MyBaseDir]\Dir2"/>
  </DirectoryMappings>
</appSettings>

0

मैं इस समाधान के साथ आया:

  1. अनुप्रयोग Settings.settings में मैंने एक वैरिएबल कॉन्फ़िगरेशनबेस परिभाषित किया है (टाइप = स्ट्रिंग स्कोप = एप्लिकेशन के साथ)
  2. मैंने Settings.settings में लक्ष्य विशेषताओं में एक चर पेश किया, उन सभी विशेषताओं को स्कोप = उपयोगकर्ता के लिए सेट किया जाना था
  3. App.xaml.cs में मैं मान पढ़ता हूं यदि कॉन्फ़िगरेशनबेस
  4. App.xaml.cs में मैंने विन्यास चर मान के साथ सभी चर बदले। रन-टाइम पर मानों को बदलने के लिए गुण स्कॉप्र = उपयोगकर्ता के लिए सेट किए जाने थे

मैं वास्तव में इस समाधान से खुश नहीं हूं क्योंकि मुझे सभी विशेषताओं को मैन्युअल रूप से बदलना होगा, अगर मैं एक नया जोड़ दूं तो मुझे इसे app.xaml.cs. में मानना ​​होगा।

यहाँ App.xaml.cs से एक कोड स्निपेट:

string configBase = Settings.Default.ConfigurationBase;
Settings.Default.CommonOutput_Directory = Settings.Default.CommonOutput_Directory.Replace("${ConfigurationBase}", configBase);

अपडेट करें

बस एक सुधार पाया (फिर app.xaml.cs से एक कोड स्निपेट):

string configBase = Settings.Default.ConfigurationBase;

foreach (SettingsProperty settingsProperty in Settings.Default.Properties)
{
    if (!settingsProperty.IsReadOnly && settings.Default[settingsProperty.Name] is string)
    {
        Settings.Default[settingsProperty.Name] = ((string)Settings.Default[settingsProperty.Name]).Replace("${ConfigurationBase}", configBase);
    }
}

अब मेरी सेटिंग्स में सभी विशेषताओं के लिए प्रतिस्थापन कार्य करता है जिसमें टाइप = स्ट्रिंग और स्कोप = उपयोगकर्ता है। मुझे लगता है कि मैं इसे इस तरह से पसंद करता हूं।

UPDATE2

गुणों पर चलते समय स्पष्ट रूप से स्कोप = अनुप्रयोग की आवश्यकता नहीं है।


0

तीन संभव समाधान

मुझे पता है कि मैं पार्टी में देर से आ रहा हूं, मैं देख रहा था कि चर कॉन्फ़िगरेशन सेटिंग्स समस्या के लिए कोई नया समाधान था या नहीं। कुछ उत्तर हैं जो मैंने पूर्व में उपयोग किए गए समाधानों को छूते हैं, लेकिन अधिकांश थोड़ा जटिल लगते हैं। मैंने सोचा कि मैं अपने पुराने समाधानों को देखूंगा और कार्यान्वयन को एक साथ रखूंगा ताकि यह उन लोगों की मदद कर सके जो एक ही समस्या से जूझ रहे हैं।

इस उदाहरण के लिए मैंने सांत्वना एप्लिकेशन में निम्न एप्लिकेशन सेटिंग का उपयोग किया है:

<appSettings>
    <add key="EnvironmentVariableExample" value="%BaseDir%\bin"/>
    <add key="StaticClassExample" value="bin"/>
    <add key="InterpollationExample" value="{0}bin"/>
  </appSettings>

1. पर्यावरण चर का उपयोग करें

मेरा मानना ​​है कि ऑटोकारो ऑटोकोरो का जवाब इस पर था। मैं केवल एक कार्यान्वयन कर रहा हूं जो दृश्य स्टूडियो को बंद किए बिना निर्माण या डिबगिंग के दौरान पर्याप्त होना चाहिए। मैंने दिन में इस घोल का उपयोग किया है ...

  • एक पूर्व-बिल्ड ईवेंट बनाएँ जो MSBuild चर का उपयोग करेगा

    चेतावनी: एक चर का उपयोग करें जिसे आसानी से प्रतिस्थापित नहीं किया जाएगा इसलिए अपने प्रोजेक्ट नाम या चर नाम के समान कुछ का उपयोग करें।

    SETX BaseDir "$(ProjectDir)"

  • परिवर्तनशील चर; निम्नलिखित जैसे कुछ का उपयोग करना:

    स्टैक ओवरफ्लो पर पर्यावरण के चर को ताज़ा करें

  • अपने कोड में सेटिंग का उपयोग करें:

'

private void Test_Environment_Variables()
{
    string BaseDir = ConfigurationManager.AppSettings["EnvironmentVariableExample"];
    string ExpandedPath = Environment.ExpandEnvironmentVariables(BaseDir).Replace("\"", ""); //The function addes a " at the end of the variable
    Console.WriteLine($"From within the C# Console Application {ExpandedPath}");
}

'

2. स्ट्रिंग प्रक्षेप का उपयोग करें:

  • स्ट्रिंग का उपयोग करें। फ़र्मैट () फ़ंक्शन

`

private void Test_Interpollation()
{
    string ConfigPath = ConfigurationManager.AppSettings["InterpollationExample"];
    string SolutionPath = Path.GetFullPath(Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, @"..\..\"));
    string ExpandedPath = string.Format(ConfigPath, SolutionPath.ToString());
    Console.WriteLine($"Using old interpollation {ExpandedPath}");
}

`

3. एक स्थिर वर्ग का उपयोग करना, यह वह समाधान है जो मैं ज्यादातर उपयोग करता हूं।

  • कार्यान्वयन

`

private void Test_Static_Class()
{
    Console.WriteLine($"Using a static config class {Configuration.BinPath}");
}

`

  • स्थिर वर्ग

`

static class Configuration
{
    public static string BinPath
    {
        get
        {
            string ConfigPath = ConfigurationManager.AppSettings["StaticClassExample"];
            string SolutionPath = Path.GetFullPath(Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, @"..\..\"));
            return SolutionPath + ConfigPath;
        }
    }
}

`

परियोजना क्रमांक:

app.config:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
    </startup>
  <appSettings>
    <add key="EnvironmentVariableExample" value="%BaseDir%\bin"/>
    <add key="StaticClassExample" value="bin"/>
    <add key="InterpollationExample" value="{0}bin"/>
  </appSettings>
</configuration>

Program.cs

using System;
using System.Configuration;
using System.IO;

namespace ConfigInterpollation
{
    class Program
    {
        static void Main(string[] args)
        {
            new Console_Tests().Run_Tests();
            Console.WriteLine("Press enter to exit");
            Console.ReadLine();
        }        
    }

    internal class Console_Tests
    {
        public void Run_Tests()
        {
            Test_Environment_Variables();
            Test_Interpollation();
            Test_Static_Class();
        }
        private void Test_Environment_Variables()
        {
            string ConfigPath = ConfigurationManager.AppSettings["EnvironmentVariableExample"];
            string ExpandedPath = Environment.ExpandEnvironmentVariables(ConfigPath).Replace("\"", "");
            Console.WriteLine($"Using environment variables {ExpandedPath}");
        }

        private void Test_Interpollation()
        {
            string ConfigPath = ConfigurationManager.AppSettings["InterpollationExample"];
            string SolutionPath = Path.GetFullPath(Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, @"..\..\"));
            string ExpandedPath = string.Format(ConfigPath, SolutionPath.ToString());
            Console.WriteLine($"Using interpollation {ExpandedPath}");
        }

        private void Test_Static_Class()
        {
            Console.WriteLine($"Using a static config class {Configuration.BinPath}");
        }
    }

    static class Configuration
    {
        public static string BinPath
        {
            get
            {
                string ConfigPath = ConfigurationManager.AppSettings["StaticClassExample"];
                string SolutionPath = Path.GetFullPath(Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, @"..\..\"));
                return SolutionPath + ConfigPath;
            }
        }
    }
}

पूर्व-निर्माण घटना:

प्रोजेक्ट सेटिंग्स -> बिल्ड इवेंट्स

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.