example - .net actualiza dinámicamente app.config

c# add app config

Question

¿Cómo recargo dinámicamente la aplicación.config en una aplicación de Windows .net? Necesito activar y desactivar el inicio de sesión de forma dinámica y no solo en función del valor al inicio de la aplicación.

ConfigurationManager.RefreshSection ("appSettings") no funciona y también he intentado abrir explícitamente el archivo de configuración usando OpenExeConfiguration, pero siempre obtengo el valor en caché al inicio de la aplicación y no el valor actual.

He aceptado la respuesta de crear una sección de configuración personalizada. Como nota al margen y error tonto: si está ejecutando desde el IDE, no tiene sentido actualizar el archivo app.config y esperar cambios. Debe modificar el archivo .exe.config en la carpeta bin / debug. Doh!

Answer 1

Creo que leí en la documentación de log4net que esto no es posible.

Intente tener el registro en un archivo de registro externo que pueda ser visto con un sistema de archivos

Actualización: lo encontré de nuevo ... http://logging.apache.org/log4net/release/manual/configuration.html#.config%20Files

No hay forma de volver a cargar app.config durante el tiempo de ejecución.

Answer 2

No creo que haya ninguna forma de hacerlo, a menos que escriba su propio lector de archivos de configuración usando XML. ¿Por qué no activar o desactivar el inicio de sesión al inicio de la aplicación según la configuración del archivo de configuración y luego activarlo o desactivarlo de forma dinámica mientras se ejecuta el programa?

Answer 3

Puede actualizar su propia sección de la forma en que dice:

ConfigurationManager.RefreshSection("yoursection/subsection");

Simplemente mueva un registro verdadero / falso en una sección y estará bien.

Answer 4

Recomendaría usar otro archivo XML y no app.config. Incluso podría ver el archivo en busca de cambios y volver a cargarlo automáticamente cuando cambie.

Answer 5

Solo una nota, en WinForms, puedes realizar cambios programáticos en tu app.config antes de que se cargue la aplicación (antes de Application.Start(new Form1()) ), siempre que uses System.Xml lugar de 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 6

En realidad usando un:

Application.restart ();

Me ha funcionado bastante bien.

Saludos

Jorge

Answer 7

Escribí esta implementación para cambiar el nivel de registro en el tiempo de ejecución y mantener el nuevo umbral en la aplicación.config (en realidad, la Application.exe.config).

La interfaz:

internal interface ILoggingConfiguration
{
  void SetLogLevel(string level);

  string GetLogLevel();
}

La implementación:

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
}

La clase de ayuda Log4NetUtils:

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

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

El código 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 8

Si está utilizando log4Net, puede hacer lo que pidió:

Aunque es posible agregar su configuración de app.config archivo app.config o web.config su proyecto, es preferible colocarlos en un archivo de configuración separado. Además del beneficio obvio de la mantenibilidad, tiene el beneficio adicional de que log4net puede colocar un objeto FileSystemWatcher en su archivo de configuración para monitorear cuándo cambia y actualizar su configuración dinámicamente.

Para usar un archivo de configuración separado, agregue un archivo llamado Log4Net.config a su proyecto y agregue el siguiente atributo a su archivo AssemblyInfo.cs:

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

Nota: para aplicaciones web, esto supone que Log4Net.config reside en la raíz web. Asegúrese de que el archivo log4net.config esté marcado como "Copiar en la salida" -> "Copiar siempre" en Propiedades.

Answer 9

Intenté utilizar el método RefreshSection y lo puse en funcionamiento con el siguiente ejemplo de código:

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

Answer 10

Lo siguiente es el truco que puede poner esto hará que config lea desde el disco.

Solo necesita guardar el archivo de configuración en modo modificado y luego actualizar esto hará que la aplicación lea el archivo desde el disco.

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