.net गतिशील रूप से रीफ्रेश करें app.config

Question

मैं एक .net विंडोज अनुप्रयोग में app.config को गतिशील रूप से कैसे लोड करूं? मुझे गतिशील रूप से लॉग ऑन चालू और बंद करना होगा और न केवल एप्लिकेशन प्रारंभ पर मूल्य के आधार पर।

कॉन्फ़िगरेशन मैनेजर। रीफ्रेशसेक्शन ("ऐपसेटिंग") काम नहीं करता है और मैंने ओपनएक्स कॉन्फ़िगरेशन का उपयोग करके कॉन्फ़िगरेशन फ़ाइल को स्पष्ट रूप से खोलने का भी प्रयास किया है, लेकिन मुझे हमेशा एप्लिकेशन स्टार्टअप पर कैश वैल्यू मिलता है, न कि वर्तमान मान।

मैंने कस्टम कॉन्फ़िगरेशन अनुभाग बनाने का उत्तर स्वीकार कर लिया है। एक साइड नोट और मूर्ख गलती के रूप में - यदि आप आईडीई से चल रहे हैं तो app.config फ़ाइल को अपडेट करने और परिवर्तनों की अपेक्षा करने में कोई बात नहीं है। यूओ को bin \ debug फ़ोल्डर में .exe.config फ़ाइल को संशोधित करना होगा। रवींद्र!

Answer 1

आप ताज़ा कर सकते हैं अपनी खुद की अनुभाग जिस तरह से आप कहते हैं:

ConfigurationManager.RefreshSection("yoursection/subsection"); 

बस एक प्रवेश सही/एक वर्ग में झूठी ले जाएँ और आप ठीक हो जाओगे।

Answer 2

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

Answer 3

मुझे लगता है कि मैंने log4net दस्तावेज़ में पढ़ा है कि यह संभव नहीं है।

एक बाहरी लॉगफ़ाइल कि एक FileSystemWatcher

अद्यतन के साथ देखा जा सकता है में प्रवेश होने का प्रयास करें: इसे फिर से मिले .. http://logging.apache.org/log4net/release/manual/configuration.html#.config%20Files

रनटाइम के दौरान app.config को फिर से लोड करने के लिए कोई तरीका नहीं है।

Answer 4

मैं एक और एक्सएमएल फ़ाइल का उपयोग करने की सिफारिश करता हूं, न कि app.config। आप परिवर्तनों के लिए फ़ाइल भी देख सकते हैं और इसे बदलते समय स्वचालित रूप से पुनः लोड कर सकते हैं।

Answer 5

आप log4net का उपयोग कर रहे हैं, तो आप आप क्या पूछा कर सकते हैं: हालांकि यह अपने प्रोजेक्ट की app.config या web.config फाइल करने के लिए अपने log4net विन्यास सेटिंग्स जोड़ना संभव है

, यह उन्हें एक अलग विन्यास फाइल में रखने के लिए बेहतर है । रखरखाव के स्पष्ट लाभ के अलावा, इसमें अतिरिक्त लाभ है कि log4net आपकी कॉन्फ़िगरेशन फ़ाइल पर FileSystemWatcher ऑब्जेक्ट रख सकता है जब यह बदलता है और इसकी सेटिंग्स को गतिशील रूप से अपडेट करता है।

अलग कॉन्फ़िग फ़ाइल का उपयोग करें, अपनी परियोजना के लिए Log4Net.config नाम की एक फ़ाइल जोड़ सकते हैं और अपने AssemblyInfo.cs फ़ाइल के लिए निम्न विशेषता जोड़ने के लिए:

[assembly: log4net.Config.XmlConfigurator(ConfigFile="Log4Net.config", Watch = true)] 

नोट: वेब अनुप्रयोगों के लिए, इस Log4Net.config बसता था मान लिया गया है वेब रूट में। log4net.config फ़ाइल को "आउटपुट में कॉपी करें" के रूप में चिह्नित किया गया है -> गुणों में "हमेशा कॉपी करें" के रूप में चिह्नित किया गया है।

Answer 6

विनफॉर्म में बस एक नोट, आप अपने ऐप में प्रोग्रामेटिक परिवर्तन कर सकते हैं।आपके आवेदन भार (Application.Start(new Form1()) से पहले) से पहले config, जब तक आप System.Configuration.ConfigurationManager

string configFile = Application.ExecutablePath + ".config"; //c:\path\exename.exe.config 
XmlDocument xdoc = new XmlDocument(); 
xdoc.Load(configFile); 
XmlNode node = xdoc.SelectSingleNode("/configuration/appSettings/add[@key='nodeToChange']/@value"); 
node.Value = "new value"; 
File.WriteAllText(setFile, xdoc.InnerXml); 

Answer 7

के बजाय System.Xml का उपयोग के रूप में वास्तव में एक का उपयोग कर:

Application.restart();

मेरे लिए बहुत अच्छा काम किया है।

सादर

जॉर्ज

Answer 8

बाद हैक जो आप इस डाल सकते हैं डिस्क से पढ़ने के लिए config कर देगा है।

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

ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None).Save(ConfigurationSaveMode.Modified); 
      ConfigurationManager.RefreshSection("appSettings"); 

Answer 9

मैं इस कार्यान्वयन रनटाइम पर लॉग स्तर को बदलने और नए treshold app.config (वास्तव में Application.exe.config) वापस करने के लिए लागू करने के लिए लिखा था।

इंटरफ़ेस:

internal interface ILoggingConfiguration 
{ 
    void SetLogLevel(string level); 

    string GetLogLevel(); 
} 

कार्यान्वयन:

internal sealed class LoggingConfigurationImpl : ILoggingConfiguration 
{ 
    #region Members 

    private static readonly ILog _logger = 
    ObjectManager.Common.Logger.GetLogger(); 
    private const string DEFAULT_NAME_SPACE = "Default.Name.Space"; 

    #endregion 

    #region Implementation of ILoggingConfiguration 

    public void SetLogLevel(string level) 
    { 
    Level threshold = Log4NetUtils.ConvertToLevel(level); 
    ILoggerRepository[] repositories = LogManager.GetAllRepositories(); 

    foreach (ILoggerRepository repository in repositories) 
    { 
     try 
     { 
     SetLogLevelOnRepository(repository, threshold); 
     } 
     catch (Exception ex) 
     { 
     _logger.ErrorFormat("Exception while changing log-level: {0}", ex); 
     } 
    } 
    PersistLogLevel(level); 
    } 

    public string GetLogLevel() 
    { 
    ILoggerRepository repository = LogManager.GetRepository(); 
    Hierarchy hierarchy = (Hierarchy) repository; 
    ILogger logger = hierarchy.GetLogger(DEFAULT_NAME_SPACE); 
    return ((Logger) logger).Level.DisplayName; 
    } 

    private void SetLogLevelOnRepository(ILoggerRepository repository, 
             Level threshold) 
    { 
    repository.Threshold = threshold; 
    Hierarchy hierarchy = (Hierarchy)repository; 
    ILogger[] loggers = hierarchy.GetCurrentLoggers(); 
    foreach (ILogger logger in loggers) 
    { 
     try 
     { 
     SetLogLevelOnLogger(threshold, logger); 
     } 
     catch (Exception ex) 
     { 
     _logger.ErrorFormat("Exception while changing log-level for 
      logger: {0}{1}{2}", logger, Environment.NewLine, ex); 
     } 
    } 
    } 

    private void SetLogLevelOnLogger(Level threshold, ILogger logger) 
    { 
    ((Logger)logger).Level = threshold; 
    } 

    private void PersistLogLevel(string level) 
    { 
    XmlDocument config = new XmlDocument(); 
    config.Load(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile); 
    string xpath = 
     String.Format("configuration/log4net/logger[@name='{0}']/level", 
     DEFAULT_NAME_SPACE); 
    XmlNode rootLoggerNode = config.SelectSingleNode(xpath); 

    try 
    { 
     rootLoggerNode.Attributes["value"].Value = level; 
     config.Save(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile); 

     ConfigurationManager.RefreshSection("log4net"); 
    } 
    catch(Exception ex) 
    { 
     _logger.ErrorFormat("error while persisting new log-level: {0}", ex); 
    } 
    } 

    #endregion 
} 

सहायक वर्ग Log4NetUtils:

public sealed class Log4NetUtils 
{ 
    private static readonly ILoggerRepository _loggerRepository = 
    LoggerManager.GetAllRepositories().First(); 

    public static Level ConvertToLevel(string level) 
    { 
    return _loggerRepository.LevelMap[level]; 
    } 
} 

XAML कोड:

<ComboBox Name="cbxLogLevel" Text="{Binding LogLevel}"> 
    <ComboBoxItem Content="DEBUG" /> 
    <ComboBoxItem Content="INFO" /> 
    <ComboBoxItem Content="WARN" /> 
    <ComboBoxItem Content="ERROR" /> 
</ComboBox> 
<Button Name="btnChangeLogLevel" 
     Command="{Binding SetLogLevelCommand}" 
     CommandParameter="{Binding ElementName=cbxLogLevel, Path=Text}" > 
      Change log level 
</Button> 

Answer 10

मैं RefreshSection विधि का उपयोग कर की कोशिश की है और निम्नलिखित कोड नमूना का उपयोग कर काम करने के लिए मिल गया:

class Program 
    { 
     static void Main(string[] args) 
     { 
      string value = string.Empty, key = "mySetting"; 
      Program program = new Program(); 

      program.GetValue(program, key); 
      Console.WriteLine("--------------------------------------------------------------"); 
      Console.WriteLine("Press any key to exit..."); 
      Console.ReadLine(); 
     } 

     /// <summary> 
     /// Gets the value of the specified key from app.config file. 
     /// </summary> 
     /// <param name="program">The instance of the program.</param> 
     /// <param name="key">The key.</param> 
     private void GetValue(Program program, string key) 
     { 
      string value; 
      if (ConfigurationManager.AppSettings.AllKeys.Contains(key)) 
      { 
       Console.WriteLine("--------------------------------------------------------------"); 
       Console.WriteLine("Key found, evaluating value..."); 
       value = ConfigurationManager.AppSettings[key]; 
       Console.WriteLine("Value read from app.confg for Key = {0} is {1}", key, value); 
       Console.WriteLine("--------------------------------------------------------------"); 

       //// Update the value 
       program.UpdateAppSettings(key, "newValue"); 
       //// Re-read from config file 
       value = ConfigurationManager.AppSettings[key]; 
       Console.WriteLine("New Value read from app.confg for Key = {0} is {1}", key, value); 
      } 
      else 
      { 
       Console.WriteLine("Specified key not found in app.config"); 
      } 
     } 

     /// <summary> 
     /// Updates the app settings. 
     /// </summary> 
     /// <param name="key">The key.</param> 
     /// <param name="value">The value.</param> 
     public void UpdateAppSettings(string key, string value) 
     { 
      Configuration configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); 

      if (configuration.AppSettings.Settings.AllKeys.Contains(key)) 
      { 
       configuration.AppSettings.Settings[key].Value = value; 
      } 

      configuration.Save(ConfigurationSaveMode.Modified); 
      ConfigurationManager.RefreshSection("appSettings"); 
     }