एक पुस्तकालय (DLL) के लिए 'app.config' के बराबर

Question

क्या app.configपुस्तकालयों (DLL) के लिए एक समान है ? यदि नहीं, तो कॉन्फ़िगरेशन सेटिंग्स को संग्रहीत करने का सबसे आसान तरीका क्या है जो एक पुस्तकालय के लिए विशिष्ट है? कृपया विचार करें कि पुस्तकालय का उपयोग विभिन्न अनुप्रयोगों में किया जा सकता है।

Answer 1

आप कर सकते हैं अलग विन्यास फाइल है, लेकिन आप इसे "मैन्युअल" पढ़ने के लिए, होगा ConfigurationManager.AppSettings["key"]ही विधानसभा चलाने का config पढ़ा जाएगा।

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

यह App.configप्रोजेक्ट फ़ोल्डर में जोड़ देगा , अपनी सेटिंग्स को <appSettings>सेक्शन के तहत वहां डाल देगा । यदि आप विज़ुअल स्टूडियो का उपयोग नहीं कर रहे हैं और फ़ाइल को मैन्युअल रूप से जोड़ रहे हैं, तो इसे ऐसा नाम देना सुनिश्चित करें: DllName.dll.config , अन्यथा नीचे दिया गया कोड ठीक से काम नहीं करेगा।

अब इस फ़ाइल से पढ़ने के लिए इस तरह के समारोह है:

string GetAppSetting(Configuration config, string key)
{
    KeyValueConfigurationElement element = config.AppSettings.Settings[key];
    if (element != null)
    {
        string value = element.Value;
        if (!string.IsNullOrEmpty(value))
            return value;
    }
    return string.Empty;
}

और इसका उपयोग करने के लिए:

Configuration config = null;
string exeConfigPath = this.GetType().Assembly.Location;
try
{
    config = ConfigurationManager.OpenExeConfiguration(exeConfigPath);
}
catch (Exception ex)
{
    //handle errror here.. means DLL has no sattelite configuration file.
}

if (config != null)
{
    string myValue = GetAppSetting(config, "myKey");
    ...
}

आपको कॉन्फ़िगरेशन मैनजर वर्ग उपलब्ध होने के लिए System.Configuration नाम स्थान का संदर्भ भी जोड़ना होगा।

प्रोजेक्ट बनाते समय, DLL के अलावा आपके पास भी DllName.dll.configफाइल होगी , यह वह फाइल है जिसे आपको DLL के साथ ही प्रकाशित करना है।

उपरोक्त मूल नमूना कोड है, पूर्ण पैमाने पर उदाहरण में रुचि रखने वालों के लिए, कृपया इस अन्य उत्तर को देखें ।

Comments

@ रोडनी string exeConfigPath = this.GetType().Assembly.Location;कुछ इस तरह बदलने की कोशिश करते हैं:string exeConfigPath = @"C:\MyFolder\DllFolder\ExeName.exe";

— शैडो विजार्ड ईयर फॉर यू

किसी भी विचार कैसे करना है अगर dll resharper यूनिट परीक्षण उपकरण द्वारा कुछ अज्ञात फ़ोल्डर में कॉपी किया जा रहा है?

— ऑटोडिडैक्ट

इसे लागू करने वाले किसी और के लिए एक टिप: आवेदन संदर्भित करके DllName.dll.config की पीढ़ी को स्वचालित करने के लिए, मैंने बस app का नाम बदल दिया। । इसके अलावा, मेरी ज़रूरत कनेक्शन स्ट्रिंग्स के लिए थी, जिसे config.ConnectionStrings.ConnectionStrings [connStringName] .ConnectionString का उपयोग करके पुनर्प्राप्त किया जा सकता है।

— जेफ जी

app.cfg फ़ाइल का नाम appcfg मानों को पढ़ने के लिए बहुत महत्वपूर्ण है, फ़ाइल का नाम "DLL_NAME.DLL.CONFIG" होना चाहिए

— सद्दामबिनसीड

मेरी अंतिम टिप्पणी के लिए सुधार। मेरे VS2017 समाधान में, मेरे परीक्षण और DLL परियोजनाओं से अपने नए, गैर-काम करने वाले App.config फ़ाइलों को हटाकर और इसे अपने परीक्षण प्रोजेक्ट में फिर से जोड़ते हुए यह अचानक काम करना शुरू कर रहा है! My App.config सेटिंग अब स्वतः DLL.configs में शामिल हो जाती है। जान में जान आई!

— Zeek2

Answer 2

दुर्भाग्य से, आपके पास निष्पादन योग्य प्रति केवल एक app.config फ़ाइल हो सकती है, इसलिए यदि आपके पास DLL आपके एप्लिकेशन में लिंक है, तो उनके पास अपनी ऐप नहीं हो सकती हैं ।config फाइलें।

समाधान है: आपको क्लास लाइब्रेरी के प्रोजेक्ट में App.config फ़ाइल डालने की आवश्यकता नहीं है।
आपने एप्लिकेशन में App.config फ़ाइल डाल दी जो आपकी कक्षा की लाइब्रेरी की dll का संदर्भ दे रही है।

उदाहरण के लिए, मान लें कि हमारे पास MyClasses.dll नाम का एक क्लास लाइब्रेरी है, जो एप्लिकेशन का उपयोग करता है।

string connect = 
ConfigurationSettings.AppSettings["MyClasses.ConnectionString"];

अब, मान लें कि हमारे पास MyApp.exe नाम का एक विंडोज़ एप्लिकेशन है जो MyClasses.dll का संदर्भ देता है। इसमें एक App.config होगा, जैसे कि एक प्रविष्टि:

<appSettings>
    <add key="MyClasses.ConnectionString"
         value="Connection string body goes here" />
</appSettings>

या

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

आशा है कि यह कुछ आइडिया देता है

Comments

ConfigurationSettingsअब अप्रचलित है और इसके द्वारा प्रतिस्थापित किया गया है ConfigurationManager, इसलिए अब समतुल्य होगाConfigurationManager.AppSettings

— कोडिंग

वोट नीचे। प्रश्न प्रति डीएल है और प्रति ऐप नहीं है। सबसे अच्छा समाधान: stackoverflow.com/a/5191101/2935383

— raiserle

मुझे संदेह है कि यह सुझाव देर-सवेर डीएलएस के मामले में काम नहीं करेगा, जिसमें उन्हें निष्पादन योग्य कॉलिंग का कोई ज्ञान नहीं होगा।

— बीनमेफ

Answer 3

कॉन्फ़िगरेशन फ़ाइलें एप्लिकेशन-स्कॉप्ड हैं और असेंबली-स्कॉप्ड नहीं हैं। इसलिए आपको अपनी लाइब्रेरी की कॉन्फ़िगरेशन फ़ाइल को हर एप्लिकेशन की कॉन्फ़िगरेशन फ़ाइल में डालना होगा जो आपके लाइब्रेरी का उपयोग कर रही है।

उस ने कहा, एप्लिकेशन की कॉन्फ़िगरेशन फ़ाइल, विशेष रूप से appSettingsअनुभाग, एक क्लास लाइब्रेरी में कॉन्फ़िगरेशन प्राप्त करना एक अच्छा अभ्यास नहीं है । यदि आपके पुस्तकालय को मापदंडों की आवश्यकता है, तो उन्हें संभवतः निर्माता, कारखाने के तरीकों आदि में विधि तर्क के रूप में पारित किया जाना चाहिए, जो भी आपके पुस्तकालय को बुला रहा है। यह क्लास लाइब्रेरी द्वारा अपेक्षित कॉन्फ़िगरेशन प्रविष्टियों को गलती से पुन: उपयोग करने से रोकता है।

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

आप MSDN पर कस्टम कॉन्फ़िगरेशन अनुभागों के बारे में अधिक जान सकते हैं और फिल हैक का भी उन पर अच्छा लेख है।

Comments

"क्लास लाइब्रेरी में कॉन्फ़िगरेशन फ़ाइल से कॉन्फ़िगरेशन प्राप्त करना एक अच्छा अभ्यास नहीं है" - मैं इससे दृढ़ता से असहमत हूं। उदाहरण के लिए, एक डीएएल क्लास लाइब्रेरी को आम तौर पर कॉन्फ़िगरेशन डेटा प्राप्त करना चाहिए जैसे कि बीएलएल टियर से यह जानकारी पास होने के बजाय एप्लिकेशन कॉन्फ़िगरेशन फ़ाइल से कनेक्शन स्ट्रिंग्स। कॉन्फ़िगरेशन का उपयोग करने वाली कोई भी फ़्रेमवर्क कक्षाएं (जैसे ASP.NET सदस्यता) इस तरह से काम करती हैं।

— जो

मैंने अपना उत्तर थोड़ा संशोधित किया। मैं अभी भी वही कह रहा हूं जो मैंने कहा था, लेकिन आप सही कह रहे हैं, मेरा कभी भी यह मतलब नहीं था कि कॉन्फ़िगरेशन फ़ाइलों का उपयोग नहीं किया जाना चाहिए। मेरा अभिप्राय यह था कि कन्वेंशन-आधारित के बजाय appSettings, कस्टम सेक्शन एक बढ़िया विकल्प प्रस्तुत करते हैं; यह बहुत ज्यादा है। ASP.NET सदस्यता का उपयोग क्या होता है।

— madd0

Answer 4

public class ConfigMan
{
    #region Members

    string _assemblyLocation;
    Configuration _configuration;

    #endregion Members

    #region Constructors

    /// <summary>
    /// Loads config file settings for libraries that use assembly.dll.config files
    /// </summary>
    /// <param name="assemblyLocation">The full path or UNC location of the loaded file that contains the manifest.</param>
    public ConfigMan(string assemblyLocation)
    {
        _assemblyLocation = assemblyLocation;
    }

    #endregion Constructors

    #region Properties

    Configuration Configuration
    {
        get
        {
            if (_configuration == null)
            {
                try
                {
                    _configuration = ConfigurationManager.OpenExeConfiguration(_assemblyLocation);
                }
                catch (Exception exception)
                {
                }
            }
            return _configuration;
        }
    }

    #endregion Properties

    #region Methods

    public string GetAppSetting(string key)
    {
        string result = string.Empty;
        if (Configuration != null)
        {
            KeyValueConfigurationElement keyValueConfigurationElement = Configuration.AppSettings.Settings[key];
            if (keyValueConfigurationElement != null)
            {
                string value = keyValueConfigurationElement.Value;
                if (!string.IsNullOrEmpty(value)) result = value;
            }
        }
        return result;
    }

    #endregion Methods
}

बस कुछ करने के लिए, मैंने एक कक्षा में शीर्ष उत्तर को वापस ले लिया। उपयोग कुछ इस प्रकार है:

ConfigMan configMan = new ConfigMan(this.GetType().Assembly.Location);
var setting = configMan.GetAppSetting("AppSettingsKey");

Answer 5

यदि आप Visual Studio (प्रोजेक्ट गुण, सेटिंग्स) में किसी क्लास लाइब्रेरी प्रोजेक्ट में सेटिंग्स जोड़ते हैं, तो यह आपके प्रोजेक्ट के लिए संबंधित userSettings / applicatioNSettings अनुभागों के साथ एक app.config फ़ाइल जोड़ेगा, और इन सेटिंग्स से इन सेटिंग्स के लिए डिफ़ॉल्ट मान .settings फ़ाइल।

हालाँकि यह कॉन्फ़िगरेशन फ़ाइल रनटाइम पर उपयोग नहीं की जाएगी - इसके बजाय क्लास लाइब्रेरी अपने होस्टिंग एप्लिकेशन के कॉन्फ़िगरेशन फ़ाइल का उपयोग करती है।

मेरा मानना ​​है कि इस फ़ाइल को बनाने का मुख्य कारण यह है कि आप सेटिंग को होस्ट एप्लिकेशन की कॉन्फ़िगरेशन फ़ाइल में कॉपी / पेस्ट कर सकते हैं।

Answer 6

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

दशमलव और डबल्स के मामले में दशमलव के अधिकार को प्राप्त करने के लिए कुछ ट्वीकिंग की आवश्यकता हो सकती है, लेकिन यह मेरे CultureInfo के लिए ठीक काम करता है ...

static class Settings
{
    static UriBuilder uri = new UriBuilder(Assembly.GetExecutingAssembly().CodeBase);
    static Configuration myDllConfig = ConfigurationManager.OpenExeConfiguration(uri.Path);
    static AppSettingsSection AppSettings = (AppSettingsSection)myDllConfig.GetSection("appSettings");
    static NumberFormatInfo nfi = new NumberFormatInfo() 
    { 
        NumberGroupSeparator = "", 
        CurrencyDecimalSeparator = "." 
    };

    public static T Setting<T>(string name)
    {
        return (T)Convert.ChangeType(AppSettings.Settings[name].Value, typeof(T), nfi);
    }
}

App.Config फ़ाइल नमूना

<add key="Enabled" value="true" />
<add key="ExportPath" value="c:\" />
<add key="Seconds" value="25" />
<add key="Ratio" value="0.14" />

उपयोग:

  somebooleanvar = Settings.Setting<bool>("Enabled");
  somestringlvar = Settings.Setting<string>("ExportPath");
  someintvar =     Settings.Setting<int>("Seconds");
  somedoublevar =  Settings.Setting<double>("Ratio");

छाया जादूगर और मैट को क्रेडिट

Comments

यह स्वीकृत उत्तर होना चाहिए। बहुत कॉम्पैक्ट और "बॉक्स के ठीक बाहर काम करता है"। अच्छा सामान

— nmarler

Answer 7

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

[TestClass]
[DeploymentItem("MyProject.Cache.dll.config")]
public class CacheTest
{
    .
    .
    .
    .
}

उन टिप्पणियों के जवाब में, जो असेंबली परियोजना के लिए विशिष्ट नहीं हो सकती हैं, वे कर सकते हैं और यह शानदार लचीलापन प्रदान करता है। जब IOC चौखटे के साथ काम कर रहा हो।

Answer 8

मैंने उसी समस्या का सामना किया और Parametersप्रोजेक्ट में एप्लिकेशन कॉन्फ़िगरेशन फ़ाइल जोड़ने के बाद एक स्थिर वर्ग बनाकर इसे हल किया :

public static class Parameters
{
    // For a Web Application
    public static string PathConfig { get; private set; } =
        Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "web.config");

    // For a Class Library
    public static string PathConfig { get; private set; } =
        Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin", "LibraryName.dll.config");

    public static string GetParameter(string paramName)
    {
        string paramValue = string.Empty;

        using (Stream stream = File.OpenRead(PathConfig))
        {
            XDocument xdoc = XDocument.Load(stream);

            XElement element = xdoc.Element("configuration").Element("appSettings").Elements().First(a => a.Attribute("key").Value == paramName);
            paramValue = element.Attribute("value").Value;
        }

        return paramValue;
    }
}

फिर इस तरह एक पैरामीटर प्राप्त करें:

Parameters.GetParameter("keyName");

Comments

प्रतिभाशाली! इससे मुझे अपने विंडोज एप्लिकेशन ड्राइवर को लक्ष्य मशीनों पर चलने वाले स्वचालित परीक्षण प्राप्त करने में मदद मिली। मेरे मामले में dlls एक परीक्षण परियोजना से थे। केवल एक चीज मैं जोड़ूंगा कि विन ऐप ड्राइवर (और संभवतः स्वचालित परीक्षण के अन्य रूप) में, बेसडायरेक्ट्री वास्तव में आउटपुट फ़ोल्डर है जो हर बार बदलता है। मुझे इस तरह से प्रतिस्थापित करना था ... AppDomain.CurrentDomain.BaseDirectory.Substring (0, AppDomain.CurrentDomain.BaseDirectory.IndexOf ("TestResults)")। इस तरह मैं अनचाहे आउटपुट फोल्डर को काट सकता था क्योंकि मेरी कॉन्फिग फाइल मेरे टेस्ट डीएलएस के समान फोल्डर में थी।

— इवान

Answer 9

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

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

मैं आपको जो करने की सिफारिश करूंगा, उदाहरण के लिए उन मूल्यों के लिए आपकी विधानसभा में वर्गों पर गुणों को परिभाषित करें

private string ExternalServicesUrl
{
  get
  {
    string externalServiceUrl = ConfigurationManager.AppSettings["ExternalServicesUrl"];
    if (String.IsNullOrEmpty(externalServiceUrl))
      throw new MissingConfigFileAppSettings("The Config file is missing the appSettings entry for: ExternalServicesUrl");
    return externalServiceUrl;
  }
}

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

MissingConfigFileAppSettings एक कस्टम अपवाद है। आप एक अलग अपवाद फेंकना चाह सकते हैं।

बेशक एक बेहतर डिजाइन उन वर्गों की पद्धति के लिए होगा जो उन मानों को विन्यास फाइल सेटिंग पर निर्भर होने के बजाय मापदंडों के रूप में प्रदान करते हैं। इस तरह से इन वर्गों का उपयोग करने वाले आवेदन यह तय कर सकते हैं कि वे इन मूल्यों को कहाँ और कैसे प्रदान करते हैं।

Comments

इसके बाद के संस्करण के लिए: अपने .NET असेंबली DLL पर xUnit परीक्षण चलाते समय, xUnit पुस्तकालय के .config, रनटाइम पर पढ़ेगा। और यह परीक्षण या DLL परियोजना में जोड़े गए किसी भी App.config की उपेक्षा करेगा।

— Zeek2

Answer 10

मौजूदा आइटम का उपयोग करें, dll परियोजना से एप्लिकेशन कॉन्फिग का चयन करें। जोड़ने पर क्लिक करने से पहले, "लिंक के रूप में जोड़ने के लिए" बटन के दाहिने हाथ की ओर थोड़ा नीचे तीर का उपयोग करें

मैं अपने देव में हर समय ऐसा करता हूं।

Answer 11

प्रस्तावना : मैं नेट 2.0 का उपयोग कर रहा हूं;

Yiannis Leoussis द्वारा पोस्ट किया गया समाधान स्वीकार्य है लेकिन मुझे इससे कुछ समस्या थी।

सबसे पहले, static AppSettingsSection AppSettings = (AppSettingsSection)myDllConfig.GetSection("appSettings");रिटर्न शून्य। मुझे इसे बदलना पड़ाstatic AppSettingSection = myDllConfig.AppSettings;

तब return (T)Convert.ChangeType(AppSettings.Settings[name].Value, typeof(T), nfi);अपवादों के लिए पकड़ नहीं होती है। इसलिए मैंने इसे बदल दिया है

try
{
    return (T)Convert.ChangeType(AppSettings.Settings[name].Value, typeof(T), nfi);
}
catch (Exception ex)
{
    return default(T);
}

यह बहुत अच्छी तरह से काम करता है लेकिन अगर आपके पास एक अलग डीएल है तो आपको हर बार कोड को हर विधानसभा के लिए फिर से लिखना होगा। इसलिए, जब भी आपको जरूरत हो, क्लास के लिए यह मेरा संस्करण है।

public class Settings
{
    private AppSettingsSection _appSettings;
    private NumberFormatInfo _nfi;

    public Settings(Assembly currentAssembly)
    {
        UriBuilder uri = new UriBuilder(currentAssembly.CodeBase);
        string configPath = Uri.UnescapeDataString(uri.Path);
        Configuration myDllConfig = ConfigurationManager.OpenExeConfiguration(configPath);
        _appSettings = myDllConfig.AppSettings;
        _nfi = new NumberFormatInfo() 
        { 
            NumberGroupSeparator = "", 
            CurrencyDecimalSeparator = "." 
        };
    }


    public T Setting<T>(string name)
    {
        try
        {
            return (T)Convert.ChangeType(_appSettings.Settings[name].Value, typeof(T), _nfi);
        }
        catch (Exception ex)
        {
            return default(T);
        }
    }
}

एक विन्यास के लिए:

<add key="Enabled" value="true" />
<add key="ExportPath" value="c:\" />
<add key="Seconds" value="25" />
<add key="Ratio" value="0.14" />

इसे इस रूप में उपयोग करें:

Settings _setting = new Settings(Assembly.GetExecutingAssembly());

somebooleanvar = _settings.Setting<bool>("Enabled");
somestringlvar = _settings.Setting<string>("ExportPath");
someintvar =     _settings.Setting<int>("Seconds");
somedoublevar =  _settings.Setting<double>("Ratio");

Comments

कृपया, विलोपन के लिए वोट की समीक्षा करें। इसे लिखते समय मेरी गलती का जवाब भेजा गया था।

— मत्तेयो गगिनजियो

Answer 12

जहां तक ​​मुझे जानकारी है, आपको लाइब्रेरी से इच्छित अनुभागों को कॉपी-पेस्ट करना होगा। एप्लिकेशन में .config और .config फ़ाइल। आपको केवल निष्पादन योग्य उदाहरण के लिए 1 app.config मिलता है।

Comments

यदि आप कस्टम कॉन्फ़िगरेशन अनुभागों का उपयोग कर रहे हैं, तो आप configSource विशेषता का उपयोग कर सकते हैं: <MySection configSource = "mysection.config" /> और कॉन्फ़िग फ़ाइल केवल dll के साथ कॉपी करें

— Jan Remunda

मैंने नए प्रश्न जोड़े हैं, जैसे कि फ़ंक्शन के बारे में कहा जाता है कि फ़ंक्शन हमेशा एक खाली स्ट्रिंग और मेल सर्वर सेटिंग्स लौटाता है> stackoverflow.com/questions/25123544/… और> stackoverflow.com/questions/25138788/… इसलिए मुझे आशा है कि कोई मुझे उनके उत्तर देगा लगभग DLL में मानों को हार्डकोड करने के किनारे पर है!

— मंकीमैक्स

Answer 13

क्यों नहीं उपयोग करें:

• [ProjectNamespace].Properties.Settings.Default.[KeyProperty] C # के लिए
• My.Settings.[KeyProperty] VB.NET के लिए

आपको बस उन गुणों को डिज़ाइन-टाइम पर अपडेट करना होगा:

[Solution Project]->Properties->Settings

Comments

यह स्वचालित रूप से dll के लिए एक विन्यास फाइल बनाएगा। लेकिन आप रनटाइम पर कॉन्फिग फ़ाइल से संशोधित मान नहीं पढ़ सकते हैं। अंत में यह आपके कॉलिंग एप्लिकेशन के मूल्यों को दिखाएगा। @Joe उत्तर भी देखें

— कोड पोप

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

— पेड्रो मोरा

Answer 14

कॉन्फ़िगरेशन से उपयोग इस तरह से बहुत आसान होना चाहिए:

var config = new MiniConfig("setting.conf");

config.AddOrUpdate("port", "1580");

if (config.TryGet("port", out int port)) // if config exist
{
    Console.Write(port);
}

अधिक जानकारी के लिए MiniConfig देखें