通过自定义属性设置特定属性的值

Question

I am currently developing a software that will be used by users that should not be able to access the back-end of it all but should still be able to easily change configuration/settings for the application. I decided the best approach would be a custom "configuration file (.cfg)" located in the root of the final build. Simple example of the .cfg file:

serveraddress='10.10.10.10'
serverport='1234'
servertimeout='15000'

Since I wanted the configuration file to easily be extended I decided to use some custom attributes and some simple LINQ. This does work like I expect it to, but since I am still a novice in .net I am afraid I have not gone with the best approach and my question is therefor: Is there anything I can do to improve this? Or is there just generally a better approach for this?

This is my code for reading the configuration file and assigning the values to it's corresponding properties.

ConfigFileHandler.cs

public void ReadConfigFile()
    {
        var cfgFile = new ConfigFile();
        var configLines = File.ReadAllLines("configfile.cfg");
        var testList = configLines.Select(line => line.Split('='))
            .Select(splitString => new Tuple<string, string>(splitString[0], splitString[1].Replace("'", "")))
            .ToList();
        foreach (var prop in typeof(ConfigFile).GetProperties())
        {
            var attrs = (ConfigFileFieldAttribute[])prop.GetCustomAttributes
                (typeof(ConfigFileFieldAttribute), false);
            foreach (var t in from attr in attrs from t in testList where t.Item1 == attr.Name select t)
            {
                prop.SetValue(cfgFile, t.Item2);
            }
        }
    }

ConfigFile.cs

 class ConfigFile
    {
        private static string _serverAddress;
        private static int _serverPort;
        private static int _serverTimeout;

        [ConfigFileField(@"serveraddress")]
        public string ServerAddress
        {
            get { return _serverAddress; }
            set { _serverAddress= value; }
        }

        [ConfigFileField(@"serverport")]
        public string ServerPort
        {
            get { return _serverPort.ToString(); }
            set { _serverPort= int.Parse(value); }
        }

        [ConfigFileField(@"servertimeout")]
        public string ServerTimeout
        {
            get { return _serverTimeout.ToString(); }
            set { _serverTimeout= int.Parse(value); }
        }
    }

any tips on writing better looking code would be highly appreciated!

---

UPDATE: Thanks for all the feedback.

Below is the final classes! https://dotnetfiddle.net/bPMnJA for a live example

Please note, this is C# 6.0

ConfigFileHandler.cs

 public class ConfigFileHandler
 {
    public void ReadConfigFile()
    {
        var configLines = File.ReadAllLines("configfile.cfg");
        var configDictionary = configLines.Select(line => line.Split('='))
        .Select(splitString => new Tuple<string, string>(splitString[0],     splitString[1].Replace("'", "")))
        .ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2);
        ConfigFile.SetDictionary(configDictionary);
    }
 }

ConfigFile.cs

 public class ConfigFile
 {
    private static Dictionary<string, string> _configDictionary;

    public string ServerAddress => PullValueFromConfig<string>("serveraddress", "10.1.1.10");

    public int ServerPort => PullValueFromConfig<int>("serverport", "3306");

    public long ServerTimeout => PullValueFromConfig<long>("servertimeout", "");


    private static T PullValueFromConfig<T>(string key, string defaultValue)
    {
        string value;
        if (_configDictionary.TryGetValue(key, out value) && value.Length > 0)
            return (T) Convert.ChangeType(value, typeof (T));
        return (T) Convert.ChangeType(defaultValue, typeof (T));

    }

    public static void SetDictionary(Dictionary<string, string> configValues)
    {
        _configDictionary = configValues;
    }
 }

Answer 1

You could keep the simplicity of your config file and get rid of the nested loops by loading the values into a dictionary and then passing that into your ConfigFile class.

    public static void ReadConfigFile()
    {
        var configLines = File.ReadAllLines("configfile.cfg");
        var testList = configLines.Select(line => line.Split('='))
            .Select(splitString => new Tuple<string, string>(splitString[0], splitString[1].Replace("'", "")))
            .ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2);

        var cfgFile = new ConfigFile(testList);
    }

The new ConfigFile class:

class ConfigFile
{
    private Dictionary<string, string> _configDictionary;

    public ConfigFile(Dictionary<string, string> configValues)
    {
        _configDictionary = configValues;
    }

    public string ServerAddress
    {
        get { return PullValueFromConfig("serveraddress", "192.168.1.1"); }
    }

    public string ServerPort
    {
        get { return PullValueFromConfig("serverport", "80"); }
    }

    public string ServerTimeout
    {
        get { return PullValueFromConfig("servertimeout", "900"); }
    }

    private string PullValueFromConfig(string key, string defaultValue)
    {
            string value;
            if (_configDictionary.TryGetValue(key, out value))
                return value;
            return defaultValue;
    }
}

Answer 2

I decided to use a custom "configuration file (.cfg)" located in the root of the final build.

Good idea. For cleaner code, you could use JSON and JSON.NET for de/serialization and put the read/write into the ConfigFile class. Here is an example that is live as a fiddle .

The ConfigFile class is responsible for loading and saving itself and uses JSON.NET for de/serialization.

public class ConfigFile
{
    private readonly static string path = "somePath.json";
    public string ServerAddress { get; set; }
    public string ServerPort { get; set; }
    public string ServerTimeout { get; set; }
    public void Save()
    {
        var json = JsonConvert.SerializeObject(this, Formatting.Indented);
        File.WriteAllText(path, json) 
    }
    public static ConfigFile Load()
    {
        var json = File.ReadAllText(path); 
        return JsonConvert.DeserializeObject<ConfigFile>(json);
    }
}

Here is how you would use it to load the file, change its properties, and save.

ConfigFile f = ConfigFile.Load();
f.ServerAddress = "0.0.0.0";
f.ServerPort = "8080";
f.ServerTimeout = "400";
f.Save();

We use the .json file extension as a convention. You could still use .cfg because it's just plain text with a specific syntax. The resultant config file content from the above usage is this:

{
    "ServerAddress":"0.0.0.0",
    "ServerPort":"8080",
    "ServerTimeout":"400"
}

You could just tell your clients to "change the numbers only". Your approach is fine, as far as I'm concerned. The above is just a cleaner implementation.

Answer 3

Firstly, I would do what Phil did, and store your testlist in a Dictionary.

var configLines = File.ReadAllLines("configfile.cfg");
var testDict = configLines.Select(line => line.Split('=', 2))
                          .ToDictionary(s => s[0], s => s[1].Replace("'", ""));

Then you can clean up the property assignment LINQ a bit:

foreach (var prop in typeof(ConfigFile).GetProperties())
{
    var attr = prop.GetCustomAttributes(false)
                   .OfType<ConfigFileFieldAttribute>()
                   .FirstOrDefault();
    string val;
    if (attr != null && testDict.TryGetValue(attr.Name, out val))
        prop.SetValue(cfgFile, val);
}

You might even be able to call:

var attr = prop.GetCustomAttributes<ConfigFileFieldAttribute>(false).FirstOrDefault();

Don't have an IDE on me so I can't check right now