C＃.NET中的全局可编辑配置设置？

Question

I want the best of both worlds: I want to be able to persist changes during runtime, like the User scoped application settings can, and I also want these settings to be global. Is there some way to accomplish this through app.config settings files? Should I look at some other way to persist global, runtime editable settings for my application?

Answer 1

The built in configuration manager in .Net which is used to deal with application settings in config files is read-only so technically, you can't do it using the built in libraries, however, the config file is just xml, so there's no reason why you can't just update the config file using the standard xml methods and then call

ConfigurationManager.RefreshSection("appSettings")

when you want to reload your settings

Answer 2

Furthermore, the OpenMappedExeConfiguration() Method of the ConfigurationManager lets you dynamically load a config file of your choosing (granted it follows the .NET xml config schema) and have your application load configuariton options from it, so you can modifcations to the file as @lomax indicated and have a common file that you can load from all your applications, using this same method.

Here's some info on OpenMappedExeConfiguration

Answer 3

Ok, this is how I solved it:

I created really basic ConfigurationSection , ConfigurationElement , and ConfigurationElementCollection implementations:

public class CoreConfigurationSection : ConfigurationSection
{
    [ConfigurationProperty("settings", IsDefaultCollection = true)]
    [ConfigurationCollection(typeof(CoreSettingCollection), AddItemName = "setting")]
    public CoreSettingCollection Settings
    {
        get
        {
            return (CoreSettingCollection)base["settings"];
        }
    }
}

public class CoreSetting : ConfigurationElement
{
    public CoreSetting() { }

    public CoreSetting(string name, string value)
    {
        Name = name;
        Value = value;
    }

    [ConfigurationProperty("name", IsRequired = true, IsKey = true)]
    public string Name
    {
        get { return (string)this["name"]; }
        set { this["name"] = value; }
    }

    [ConfigurationProperty("value", DefaultValue = null, IsRequired = true, IsKey = false)]
    public string Value
    {
        get { return (string)this["value"]; }
        set { this["value"] = value; }
    }
}

public class CoreSettingCollection : ConfigurationElementCollection
{
    public new string this[string name]
    {
        get { return BaseGet(name) == null ? string.Empty : ((CoreSetting)BaseGet(name)).Value; }
        set { Remove(name); Add(name, value); }
    }

    public void Add(string name, string value)
    {
        if (!string.IsNullOrEmpty(value))
            BaseAdd(new CoreSetting(name, value));
    }

    public void Remove(string name)
    {
        if (BaseGet(name) != null)
            BaseRemove(name);
    }

    protected override ConfigurationElement CreateNewElement()
    {
        return new CoreSetting();
    }

    protected override object GetElementKey(ConfigurationElement element)
    {
        return ((CoreSetting)element).Name;
    }
}

And then a class to manage the configuration file:

public static class Settings
{
    private static string _root { get { return "core"; } }

    private static Configuration Load()
    {
        string filename = Path.Combine(Core.BaseDirectory, "core.config");

        var mapping = new ExeConfigurationFileMap {ExeConfigFilename = filename};
        var config = ConfigurationManager.OpenMappedExeConfiguration(mapping, ConfigurationUserLevel.None);

        var section = (CoreConfigurationSection)config.GetSection(_root);

        if (section == null)
        {
            Console.Write("Core: Building core.config...");

            section = new CoreConfigurationSection();
            config.Sections.Add(_root, section);
            Defaults(section);
            config.Save(ConfigurationSaveMode.Modified);

            Console.WriteLine("done");
        }

        return config;
    }

    private static void Defaults(CoreConfigurationSection section)
    {
        section.Settings["Production"] = "false";
        section.Settings["Debug"] = "false";
        section.Settings["EventBot"] = "true";
        section.Settings["WebAccounting"] = "true";
        section.Settings["AllowPlayers"] = "true";
    }

    #region Accessors

    public static string Get(string setting)
    {
        var config = Load();
        var section = (CoreConfigurationSection)config.GetSection(_root);

        return section.Settings[setting];
    }

    public static bool GetBoolean(string setting)
    {
        var config = Load();
        var section = (CoreConfigurationSection)config.GetSection(_root);

        return section.Settings[setting].ToLower() == "true";
    }

    public static void Set(string setting,string value)
    {
        var config = Load();
        var section = (CoreConfigurationSection)config.GetSection(_root);

        if (value == null)
            section.Settings.Remove(setting);

        section.Settings[setting] = value;
        config.Save(ConfigurationSaveMode.Modified);
    }

    public static void SetBoolean(string setting, bool value)
    {
        var config = Load();
        var section = (CoreConfigurationSection)config.GetSection(_root);

        section.Settings[setting] = value.ToString();
        config.Save(ConfigurationSaveMode.Modified);
    }

    #endregion

    #region Named settings

    public static bool Production
    {
        get { return GetBoolean("Production"); }
        set { SetBoolean("Production", value); }
    }

    public static bool Debug
    {
        get { return GetBoolean("Debug"); }
        set { SetBoolean("Debug", value); }
    }

    public static bool EventBot
    {
        get { return GetBoolean("EventBot"); }
        set { SetBoolean("EventBot", value); }
    }

    public static bool WebAccounting
    {
        get { return GetBoolean("WebAccounting"); }
        set { SetBoolean("WebAccounting", value); }
    }

    public static bool AllowPlayers
    {
        get { return GetBoolean("AllowPlayers"); }
        set { SetBoolean("AllowPlayers", value); }
    }

    #endregion
}

I couldn't really think of a better way to make typed configurations than hardcoding them, but other than that it seems pretty solid to me, you can create and update configurations at runtime, they are global, editable, and located on my application root, so basically that covers all features I wanted.

The core.config file is created at runtime if it doesn't exist, this is verified whenever you try to load or save a setting, with some default values just to "get started"... (you can skip that "initialization" though.

The core.config file looks like this

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <configSections>
        <section name="core" type="Server.CoreConfigurationSection, ServerCore, Version=2.1.4146.38077, Culture=neutral, PublicKeyToken=null" />
    </configSections>
    <core>
        <settings>
            <setting name="Production" value="false" />
            <setting name="Debug" value="false" />
            <setting name="EventBot" value="true" />
            <setting name="WebAccounting" value="true" />
            <setting name="AllowPlayers" value="true" />
        </settings>
    </core>
</configuration>