.NET कॉन्फ़िगरेशन (app.config / web.config / settings.settings)

Question

मेरे पास एक .NET अनुप्रयोग है जिसमें डिबग और रिलीज़ बिल्ड के लिए अलग-अलग कॉन्फ़िगरेशन फ़ाइलें हैं। जैसे डिबग app.config फ़ाइल एक विकास SQL सर्वर के लिए इंगित करता है जिसमें डिबगिंग सक्षम है और रिलीज़ लक्ष्य लाइव SQL सर्वर को इंगित करता है। अन्य सेटिंग्स भी हैं, जिनमें से कुछ डिबग / रिलीज़ में भिन्न हैं।

मैं वर्तमान में दो अलग-अलग कॉन्फ़िगरेशन फ़ाइलों (debug.app.config और release.app.config) का उपयोग करता हूं। मेरे पास प्रोजेक्ट पर एक बिल्ड इवेंट है, जो कहता है कि अगर यह रिलीज़ बिल्ड है, तो ऐप को रिलीज़ करें ।app.config को कॉपी करें ।config, अन्यथा debug.app.config को कॉपी करें ।config को कॉपी करें।

समस्या यह है कि एप्लिकेशन सेटिंग्स से अपनी सेटिंग्स प्राप्त करने लगता है। फाइल सेटिंग, इसलिए मुझे Visual Studio में settings.settings खोलना होगा जो तब संकेत देता है कि सेटिंग्स बदल गई हैं इसलिए मैं परिवर्तनों को स्वीकार करता हूं, settings.settings और है इसे सही सेटिंग्स का उपयोग करने के लिए पुनर्निर्माण करने के लिए।

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

Comments

मैं खिड़कियों में डिबग को अक्षम करना चाहता हूं, मैंने डिबग सेटिंग्स में सभी चेक बॉक्स को अनचेक करके कोशिश की है, लेकिन फिर भी मैं बिन रिलीज एक्स को डीबग कर सकता हूं .. कोई भी इस पर मेरी मदद कर सकता है ..

— विनोथ नारायण

Answer 1

कोई भी कॉन्फ़िगरेशन जो वातावरण में भिन्न हो सकती है उसे मशीन स्तर पर संग्रहीत किया जाना चाहिए , न कि एप्लिकेशन स्तर पर । (कॉन्फ़िगरेशन स्तरों के बारे में अधिक जानकारी।)

ये विन्यास तत्व के प्रकार हैं जो मैं आमतौर पर मशीन स्तर पर संग्रहीत करता हूं:

• अनुप्रयोग सेटिंग
• कनेक्शन तार
• खुदरा = true
• श्रीमती सेटिंग्स
• स्वास्थ्य की निगरानी
• मेजबानी का माहौल
• मशीन की

जब प्रत्येक वातावरण (डेवलपर, एकीकरण, परीक्षण, चरण, लाइव) की c: \ Windows \ Microsoft.NET \ फ्रेमवर्क 64 \ v2.0.50727 \ CONFIG निर्देशिका में अपनी अनूठी सेटिंग है , तो आप बिना किसी वातावरण के बीच अपने आवेदन कोड को बढ़ावा दे सकते हैं पोस्ट-बिल्ड संशोधन।

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

मैं 7 वर्षों से ऐसा कर रहा हूं, 25 से अधिक विभिन्न कंपनियों में 200 से अधिक ASP.NET एप्लिकेशन हैं। (डींग मारने की कोशिश नहीं कर रहा है, बस आपको बताना चाहता हूं कि मैंने कभी ऐसी स्थिति नहीं देखी है जहां यह दृष्टिकोण काम नहीं करता है।)

Comments

ऐसी स्थिति के बारे में जो आप वेब सर्वर को नियंत्रित नहीं करते हैं और इसलिए मशीन-स्तर के कॉन्फ़िगरेशन को नहीं बदल सकते हैं? उदाहरणों में एक उद्यम में कई विभागों के बीच साझा किया गया एक 3-पार्टी वेब सर्वर या एक वेब सर्वर शामिल है।

— रेशनलगीक

काम नहीं करेगा। लेकिन आभासी मशीनों के युग में, अमेज़ॅन ईसी 2, और डेल से $ 400 सर्वर, क्या कोई भी वास्तव में साझा मशीनों पर कुछ भी गंभीर है? बिल्कुल भी कॉल करने की कोशिश नहीं कर रहा है - मुझे वास्तव में लगता है कि यदि आप एक साझा वेब सर्वर पर काम कर रहे हैं तो आपको पुनर्मूल्यांकन करना चाहिए।

— पोर्टमैन

अधिकांश कॉर्पोरेट्स जिन्होंने आंतरिक साइटों के साथ काम किया है, एक सर्वर पर कई अनुप्रयोगों की मेजबानी करते हैं - एक कॉर्पोरेट स्तर पर पुनर्मूल्यांकन करना होगा

— एमपीटीचार्ड

एक सर्वर पर एक से अधिक एप्लिकेशन ठीक हैं, जब तक कि ऐप्स समान "पर्यावरण" में हैं। यानी, आप App2 के DEV उदाहरण के रूप में एक ही सर्वर पर App1 का LIVE उदाहरण नहीं चाहेंगे। उदाहरण के लिए, आपकी SMTP सेटिंग्स आपके सभी अनुप्रयोगों में साझा की जाएंगी। उत्पादन में, आप एक वास्तविक मेल सर्वर को इंगित करते हैं; विकास में, आप डिस्क पर एक फ़ाइल को इंगित करते हैं।

— पोर्टमैन

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

— मिगुएल मैडेरो

Answer 2

यह कुछ लोगों को Settings.settings और App.config से निपटने में मदद कर सकता है: Visual Studio (Visual Studio 2008 मेरे मामले में) Settings.settings ग्रिड में किसी भी मान को संपादित करते समय गुण फलक में GenerateDefaultValueInCode विशेषता के लिए देखें।

यदि आप GenerateDefaultValueInCode को True (सच यहाँ डिफ़ॉल्ट है!) सेट करते हैं, तो डिफ़ॉल्ट मान EXE (या DLL) में संकलित किया जाता है, आप इसे सादे फ़ाइल संपादक में खोलने पर फ़ाइल में एम्बेडेड पा सकते हैं।

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

Comments

यह ठीक है कि इस पिछले सप्ताहांत में मेरे साथ क्या हुआ। मैंने बहुत सारे बाल निकाले, यह जानने की कोशिश कर रहा था कि मेरा ऐप मेरी ऐप को अनदेखा क्यों कर रहा है। फाइल फाइल! यह एक वेब सेवा से जुड़ने वाला है और सेवा url मेरे app.config में है। मेरे लिए अज्ञात, जब मैंने वेब संदर्भ बनाया, तो उसने एक Settings.Settings फ़ाइल भी बनाई और कोड में डिफ़ॉल्ट मान को हार्डकोड किया। यहां तक ​​कि जब मैंने अंततः सेटिंग्स फ़ाइल का पता लगाया (और हटा दिया गया), तो वह डिफ़ॉल्ट मान हार्डकोड में रहा और एक्सई में एम्बेडेड हो गया। अधिक निराश!! इस पोस्ट के लिए धन्यवाद, अब मैं उस "फीचर" से छुटकारा पा सकता हूं

— माइक के

+1 यह उत्तर महत्वपूर्ण है: यदि आप चाहते हैं कि आपकी सेटिंग ऐप में जाए। फाइल फ़ाइल, इसकी GenerateDefaultValueInCode विशेषता को गलत पर सेट करें (डिफ़ॉल्ट सही है)।

— सबुनकु

Answer 3

यहाँ एक संबंधित प्रश्न है:

अपनी निर्माण प्रक्रिया में सुधार

विन्यास फाइल सेटिंग्स को ओवरराइड करने का एक तरीका है:

<appSettings file="Local.config">

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

यदि आप कॉन्फ़िगर वर्गों का उपयोग कर रहे हैं, तो समतुल्य है:

configSource="Local.config"

बेशक, अन्य मशीनों से सभी Local.config फ़ाइलों की बैकअप प्रतियां बनाना और उन्हें कहीं न कहीं जांचना एक अच्छा विचार है, लेकिन वास्तविक समाधानों के हिस्से के रूप में नहीं। प्रत्येक डेवलपर Local.config फ़ाइल पर एक "अनदेखा" करता है, ताकि उसमें चेक न हो, जो हर किसी की फ़ाइल को अधिलेखित कर देगा।

(आपको वास्तव में इसे "Local.config" कहने की ज़रूरत नहीं है, बस यही मेरा उपयोग है)

Answer 4

मैं जो पढ़ रहा हूं, उससे ऐसा लगता है कि आप अपनी निर्माण प्रक्रिया के लिए विजुअल स्टूडियो का उपयोग कर रहे हैं। क्या आपने इसके बजाय MSBuild और Nant का उपयोग करने के बारे में सोचा है ?

Nant का xml सिंटैक्स थोड़ा अजीब है लेकिन एक बार जब आप इसे समझ जाते हैं, तो जो आपने उल्लेख किया है वह बहुत तुच्छ हो जाता है।

<target name="build">
    <property name="config.type" value="Release" />

    <msbuild project="${filename}" target="Build" verbose="true" failonerror="true">
        <property name="Configuration" value="${config.type}" />
    </msbuild>

    <if test="${config.type == 'Debug'}">
        <copy file=${debug.app.config}" tofile="${app.config}" />
    </if>

    <if test="${config.type == 'Release'}">
        <copy file=${release.app.config}" tofile="${app.config}" />
    </if>

</target>

Answer 5

मेरे लिए ऐसा लगता है कि आप विजुअल स्टूडियो 2005 वेब परिनियोजन प्रोजेक्ट s से लाभ उठा सकते हैं ।

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

त्वरित अवलोकन / नमूना के लिए स्कॉट गु से इस ब्लॉग प्रविष्टि पर एक नज़र डालें ।

Answer 6

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

  <xmlpoke
    file="${stagingTarget}/web.config"
    xpath="/configuration/system.web/compilation/@debug"
    value="true"
  />

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

Answer 7

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

उन्होंने अभी हाल ही में एक केंद्रीय वेबसेवा लिखी है जो मशीन में दिए मान से सही कनेक्शन स्ट्रिंग वापस भेजती है ।config value।

क्या यह सबसे अच्छा समाधान है? शायद नहीं, लेकिन यह उनके लिए काम करता है।

Comments

वास्तव में मुझे लगता है कि यह बहुत खूबसूरत है, क्योंकि मैं एक समाधान के भीतर दिखने वाले विभिन्न संस्करणों को रखना पसंद करता हूं, भले ही वे जीवित न हों।

— अन्नकूट

यह बहुत पेचीदा उपाय है। कार्रवाई में इसका एक उदाहरण देखना पसंद करेंगे।

— माइक के

Answer 8

मेरे द्वारा ठीक किए गए समाधानों में से एक WebDeploymentProject का उपयोग कर रहा था। मेरे पास अपनी साइट में 2/3 अलग-अलग web.config फाइलें थीं, और प्रकाशित पर, चयनित कॉन्फ़िगरेशन मोड (रिलीज़ / स्टेजिंग / आदि ...) के आधार पर, मैं Web.Release.config पर कॉपी करूँगा और इसे वेब पर नाम बदल दूंगा। AfterBuild घटना में कॉन्फ़िगर करें, और जिन्हें मुझे ज़रूरत नहीं है उन्हें हटाएं (उदाहरण के लिए Web.Staging.config)।

<Target Name="AfterBuild">
    <!--Web.config -->
    <Copy Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' " SourceFiles="$(SourceWebPhysicalPath)\Web.Release.config" DestinationFiles="$(OutputPath)\Web.config" />
    <Copy Condition=" '$(Configuration)|$(Platform)' == 'Staging|AnyCPU' " SourceFiles="$(SourceWebPhysicalPath)\Web.Staging.config" DestinationFiles="$(OutputPath)\Web.config" />
    <!--Delete extra files -->
    <Delete Files="$(OutputPath)\Web.Release.config" />
    <Delete Files="$(OutputPath)\Web.Staging.config" />
    <Delete Files="@(ProjFiles)" />
  </Target>

Answer 9

आपको यहां एक और समाधान मिलेगा: ASP.NET में विकास / यूएटी / उत्पादन वातावरण के बीच विन्यास को बदलने का सबसे अच्छा तरीका? जो web.config को ट्रांसफर करने के लिए XSLT का उपयोग करता है।

NAnt का उपयोग करने पर कुछ अच्छे उदाहरण भी हैं।

Answer 10

हमारी परियोजना में वही मुद्दा है जहां हमें देव, क्यूए, उट और ठेस के लिए विन्यास बनाए रखना था। यहाँ पर हमने अनुसरण किया है (केवल तभी लागू होता है जब आप MSBuild से परिचित हों):

MSBuild सामुदायिक कार्य विस्तार के साथ MSBuild का उपयोग करें। इसमें 'XmlMassUpdate' कार्य शामिल है जो किसी भी XML फ़ाइल में 'बड़े पैमाने पर अपडेट' प्रविष्टियां कर सकता है जब आप इसे शुरू करने के लिए सही नोड देते हैं।

लागू करने के लिए:

1) आपके पास एक कॉन्फिग फाइल होनी चाहिए जिसमें आपकी देव एनवी प्रविष्टियां होंगी; यह आपके समाधान में विन्यास फाइल है।

2) आपको एक 'सबस्टीट्यूशंस.एक्सएमएल' फाइल रखने की जरूरत है, जिसमें प्रत्येक पर्यावरण के लिए केवल प्रविष्टियां हैं जो अलग-अलग हैं (AppSettings और ConnectionStrings)। पर्यावरण में परिवर्तन नहीं करने वाली प्रविष्टियों को इस फ़ाइल में डालने की आवश्यकता नहीं है। वे समाधान की web.config फ़ाइल में रह सकते हैं और कार्य द्वारा छुआ नहीं जाएगा

3) अपनी बिल्ड फ़ाइल में, बस XML मास अपडेट कार्य को कॉल करें और एक पैरामीटर के रूप में सही वातावरण प्रदान करें।

नीचे उदाहरण देखें:

    <!-- Actual Config File -->
    <appSettings>
        <add key="ApplicationName" value="NameInDev"/>
        <add key="ThisDoesNotChange" value="Do not put in substitution file" />
    </appSettings>

    <!-- Substitutions.xml -->
    <configuration xmlns:xmu="urn:msbuildcommunitytasks-xmlmassupdate">
      <substitutions>
        <QA>
           <appSettings>
            <add xmu:key="key" key="ApplicationName" value="NameInQA"/>
           </appSettings>            
        </QA>
        <Prod>
          <appSettings>
            <add xmu:key="key" key="ApplicationName" value="NameInProd"/>
          </appSettings>            
        </Prod>
     </substitutions>
    </configuration>


<!-- Build.xml file-->

    <Target Name="UpdateConfigSections">
            <XmlMassUpdate ContentFile="Path\of\copy\of\latest web.config" SubstitutionsFile="path\of\substitutionFile" ContentRoot="/configuration" SubstitutionsRoot="/configuration/substitutions/$(Environment)" />
        </Target>

replace क्यूए ’या based प्रोड्यूस’ के साथ replace एनवाय ’पर आधारित Prod $ एनवायरनमेंट’ को बदलें। आप निर्माण कर रहे हैं ध्यान दें कि आपको किसी भी संभावित गैर-वसूली योग्य गलतियों से बचने के लिए एक कॉन्फिगर फाइल की कॉपी पर काम करना चाहिए न कि वास्तविक कॉन्फिग फाइल पर।

बस बिल्ड फ़ाइल को चलाएं और फिर अद्यतन तैनाती फ़ाइल को अपने परिनियोजन वातावरण में ले जाएँ और आप कर रहे हैं!

बेहतर अवलोकन के लिए, इसे पढ़ें:

http://blogs.microsoft.co.il/blogs/dorony/archive/2008/01/18/easy-configuration-deployment-with-msbuild-and-the-xmlmassupdate-task.aspx

Answer 11

आप की तरह मैंने भी 'मल्टी' ऐप सेट किया है ।config - जैसे app.configDEV, app.configTEST, app.config.LOCAL। मुझे सुझाए गए कुछ उत्कृष्ट विकल्प दिखाई देते हैं, लेकिन अगर आपको यह आपके लिए काम करने का तरीका पसंद है, तो मैं निम्नलिखित जोड़ूंगा:

मेरे पास
<appSettings>
<add key = "Env" value = "[Local] "/> प्रत्येक ऐप के लिए है जिसे मैं शीर्षक में UI में जोड़ देता हूं: configurationManager.AppSettings.Get ("Env") से;

मैं सिर्फ उसी का नाम बदल रहा हूं जिसे मैं लक्षित कर रहा हूं (मेरे पास 8 एप्लिकेशन है जिसमें बहुत सारे डेटाबेस / wcf कॉन्फिग के साथ 4 ईवनोमेंट्स हैं)। प्रत्येक में clickonce के साथ तैनात करने के लिए, मैं प्रोजेक्ट में 4 सीटिंग्स बदलता हूं और जाता हूं। (यह मैं स्वचालित करना पसंद करूंगा)

मेरा एकमात्र गोचा एक बदलाव के बाद 'सभी को साफ' करने के लिए याद रखना है, क्योंकि पुराने नाम मैनुअल रनेम के बाद 'अटक' जाते हैं। (जो मुझे लगता है कि आप सेटिंग की समस्या को ठीक कर देंगे)।

मुझे यह अच्छी तरह से काम करता है (एक दिन मुझे MSBuild / NAnt देखने का समय मिलेगा)

Answer 12

web.config:

जब आप IIS पर अपने एप्लिकेशन को होस्ट करना चाहते हैं तो Web.config की आवश्यकता होती है। Web.config यह कॉन्फ़िगर करने के लिए IIS के लिए एक अनिवार्य कॉन्फिग फाइल है कि यह Kestrel के सामने रिवर्स प्रॉक्सी के रूप में कैसे व्यवहार करेगा। यदि आप इसे IIS पर होस्ट करना चाहते हैं, तो आपको web.config बनाए रखना होगा।

AppSetting.json:

IIS की चिंता न करने वाली अन्य सभी चीज़ों के लिए, आप AppSetting.json का उपयोग करें। AppSetting.json का उपयोग Asp.Net कोर होस्टिंग के लिए किया जाता है। ASP.NET Core वर्तमान परिवेश को निर्धारित करने के लिए "ASPNETCORE_ENVIRONMENT" पर्यावरण चर का उपयोग करता है। डिफ़ॉल्ट रूप से, यदि आप इस मान को सेट किए बिना अपना एप्लिकेशन चलाते हैं, तो यह स्वचालित रूप से उत्पादन वातावरण में डिफ़ॉल्ट हो जाएगा और "AppSetting.production.json" फ़ाइल का उपयोग करता है। जब आप Visual Studio के माध्यम से डिबग करते हैं तो यह पर्यावरण को विकास के लिए सेट करता है इसलिए यह "AppSetting.json" का उपयोग करता है। विंडोज पर होस्टिंग पर्यावरण चर सेट करने का तरीका समझने के लिए इस वेबसाइट को देखें।

app.config:

App.config .NET द्वारा उपयोग की जाने वाली एक और कॉन्फ़िगरेशन फ़ाइल है जो मुख्य रूप से विंडोज फॉर्म, विंडोज सर्विसेज, कंसोल एप्स और डब्ल्यूपीएफ अनुप्रयोगों के लिए उपयोग की जाती है। जब आप कंसोल एप्लिकेशन एप्लिकेशन के माध्यम से अपने Asp.Net कोर होस्टिंग शुरू करते हैं। इसका उपयोग भी किया जाता है।

---

टी एल; डॉ

कॉन्फ़िगरेशन फ़ाइल का विकल्प होस्टिंग वातावरण द्वारा निर्धारित किया जाता है जिसे आप सेवा के लिए चुनते हैं। यदि आप अपनी सेवा की मेजबानी के लिए IIS का उपयोग कर रहे हैं, तो Web.config फ़ाइल का उपयोग करें। यदि आप किसी अन्य होस्टिंग वातावरण का उपयोग कर रहे हैं, तो App.config फ़ाइल का उपयोग करें। कॉन्फ़िगरेशन फ़ाइल दस्तावेज़ का उपयोग करके कॉन्फ़िगरेशन सेवाएँ देखें और ASP.NET कोर में कॉन्फ़िगरेशन भी देखें ।

Answer 13

यह ऊपर asp.net कहता है, तो क्यों डेटाबेस में अपनी सेटिंग्स को बचाने के लिए और उन्हें पुनः प्राप्त करने के लिए एक कस्टम-कैश का उपयोग न करें?

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

एक कस्टम कैश का उदाहरण:

public enum ConfigurationSection
{
    AppSettings
}

public static class Utility
{
    #region "Common.Configuration.Configurations"

    private static Cache cache = System.Web.HttpRuntime.Cache;

    public static String GetAppSetting(String key)
    {
        return GetConfigurationValue(ConfigurationSection.AppSettings, key);
    }

    public static String GetConfigurationValue(ConfigurationSection section, String key)
    {
        Configurations config = null;

        if (!cache.TryGetItemFromCache<Configurations>(out config))
        {
            config = new Configurations();
            config.List(SNCLavalin.US.Common.Enumerations.ConfigurationSection.AppSettings);
            cache.AddToCache<Configurations>(config, DateTime.Now.AddMinutes(15));
        }

        var result = (from record in config
                      where record.Key == key
                      select record).FirstOrDefault();

        return (result == null) ? null : result.Value;
    }

    #endregion
}

namespace Common.Configuration
{
    public class Configurations : List<Configuration>
    {
        #region CONSTRUCTORS

        public Configurations() : base()
        {
            initialize();
        }
        public Configurations(int capacity) : base(capacity)
        {
            initialize();
        }
        public Configurations(IEnumerable<Configuration> collection) : base(collection)
        {
            initialize();
        }

        #endregion

        #region PROPERTIES & FIELDS

        private Crud _crud; // Db-Access layer

        #endregion

        #region EVENTS
        #endregion

        #region METHODS

        private void initialize()
        {
            _crud = new Crud(Utility.ConnectionName);
        }

        /// <summary>
        /// Lists one-to-many records.
        /// </summary>
        public Configurations List(ConfigurationSection section)
        {
            using (DbCommand dbCommand = _crud.Db.GetStoredProcCommand("spa_LIST_MyConfiguration"))
            {
                _crud.Db.AddInParameter(dbCommand, "@Section", DbType.String, section.ToString());

                _crud.List(dbCommand, PopulateFrom);
            }

            return this;
        }

        public void PopulateFrom(DataTable table)
        {
            this.Clear();

            foreach (DataRow row in table.Rows)
            {
                Configuration instance = new Configuration();
                instance.PopulateFrom(row);
                this.Add(instance);
            }
        }

        #endregion
    }

    public class Configuration
    {
        #region CONSTRUCTORS

        public Configuration()
        {
            initialize();
        }

        #endregion

        #region PROPERTIES & FIELDS

        private Crud _crud;

        public string Section { get; set; }
        public string Key { get; set; }
        public string Value { get; set; }

        #endregion

        #region EVENTS
        #endregion

        #region METHODS

        private void initialize()
        {
            _crud = new Crud(Utility.ConnectionName);
            Clear();
        }

        public void Clear()
        {
            this.Section = "";
            this.Key = "";
            this.Value = "";
        }
        public void PopulateFrom(DataRow row)
        {
            Clear();

            this.Section = row["Section"].ToString();
            this.Key = row["Key"].ToString();
            this.Value = row["Value"].ToString();
        }

        #endregion
    }
}