Configuration File INI? XML? Other?

Question

I currently work for a School district and we are trying to create a C# exe for our toolkit. We are new to C# and are learning it but want to use it due to its flexibility. The C# toolkit will be used to automatically set up new or reimaged computers with settings, programs, Regedit changes, and preferences we have chosen.

We have a working version we hard coded in powershell that we are transferring over to c#.

The question we currently have is how we could use a settings/config file such as an ini or xml to pull generic information from and populate our functions and variables. This would be so we could create general config files we could select and run. For Example:

[Server]
IP=172.1.0.10
Port=9999
PathToCSV=\\c:\Files.csv
[Client]
RestartComputerAfterScript=1
Install.Browser.Firefox=1
Install.Browser.Chrome=1
Install.Java=0
Install.PrinterLogic=1
SysConfig.TempLoc=d:\TEMP

This ini file would be selected from our C# GUI and populate that:

1. The computer would restart after script was run using value 1
2. Firefox would be installed using value 1
3. Java would not be installed using value 0 etc.

We eventually will also try to pass in other variables like registry paths and values, etc.

Does anyone have a suggestion on how we could use an INI or have a better suggestion for creating build config files?

Resources I have looked into: INI: https://www.codeproject.com/Articles/1966/An-INI-file-handling-class-using-C

Answer 1

If you're open to other file formats, I would use JSON, because of its simplicity and ease of use.

Using the wonderful library Newtonsoft.Json:

Modal Classes:

class Server
{
    public string IP { get; set; }
    public int Port { get; set; }
    public string PathToCSV { get; set; }
}

class Client
{
    public bool RestartComputerAfterScript { get; set; }
    public List<string> Install { get; set; }
    public string TempLoc { get; set; }
}

class Config
{
    public Server ServerConfig { get; set; }
    public Client ClientConfig { get; set; }
}

config.json:

{
    "ServerConfig": {
        "IP": "172.1.0.10",
        "Port": 9999,
        "PathToCSV": "C:\\Files.csv"
    },
    "ClientConfig": {
        "RestartComputerAfterScript": true,
        "Install": [
            "Firefox",
            "Chrome",
            "PrinterLogic"
        ],
        "TempLoc": "D:\\TEMP"
    }
}

Read the file from disk:

public static Config Read(string path)
{
    return JsonConvert.DeserializeObject<Config>(System.IO.File.ReadAllText(path));
}

Save a config file:

public static void Write(string path, Config config)
{
    System.IO.File.WriteAllText(path, JsonConvert.SerializeObject(config, Formatting.Indented));
}

Answer 2

The .Net Framework has a ConfigurationManager class that as designed for this purpose..

Excerpt:

XML

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <startup> 
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>
  <appSettings>
    <add key="Setting1" value="May 5, 2014"/>
    <add key="Setting2" value="May 6, 2014"/>
  </appSettings>
</configuration>

Code:

using System;
using System.Configuration;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            ReadAllSettings();
            ReadSetting("Setting1");
            ReadSetting("NotValid");
            AddUpdateAppSettings("NewSetting", "May 7, 2014");
            AddUpdateAppSettings("Setting1", "May 8, 2014");
            ReadAllSettings();
        }

        static void ReadAllSettings()
        {
            try
            {
                var appSettings = ConfigurationManager.AppSettings;

                if (appSettings.Count == 0)
                {
                    Console.WriteLine("AppSettings is empty.");
                }
                else
                {
                    foreach (var key in appSettings.AllKeys)
                    {
                        Console.WriteLine("Key: {0} Value: {1}", key, appSettings[key]);
                    }
                }
            }
            catch (ConfigurationErrorsException)
            {
                Console.WriteLine("Error reading app settings");
            }
        }

        static void ReadSetting(string key)
        {
            try
            {
                var appSettings = ConfigurationManager.AppSettings;
                string result = appSettings[key] ?? "Not Found";
                Console.WriteLine(result);
            }
            catch (ConfigurationErrorsException)
            {
                Console.WriteLine("Error reading app settings");
            }
        }

        static void AddUpdateAppSettings(string key, string value)
        {
            try
            {
                var configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
                var settings = configFile.AppSettings.Settings;
                if (settings[key] == null)
                {
                    settings.Add(key, value);
                }
                else
                {
                    settings[key].Value = value;
                }
                configFile.Save(ConfigurationSaveMode.Modified);
                ConfigurationManager.RefreshSection(configFile.AppSettings.SectionInformation.Name);
            }
            catch (ConfigurationErrorsException)
            {
                Console.WriteLine("Error writing app settings");
            }
        }
    }
}

And another option is to use Settings.

Answer 3

I personally prefer having my config in XML, or in case of a web app in JSON due to consistency.
One thing that INI format does provide is that it's readable to non-tech people as well.

Nevertheless if you're interested in working with INI format then may I suggest you to try out my INI library. It can simplify your tasks of processing the INI file.
Additionally I would suggest you to take a look at parsing and mapping features, in short they would enable you for example to map "0" values as "false" and "1" values as "true" and then you could retrieve those values in Boolean type from your INI keys. See the following example:

IniFile ini = new IniFile();
ini.Load(@"C:\Files\Sample.ini");

ini.ValueMappings.Add("0", false);
ini.ValueMappings.Add("1", true);

IniSection section = ini.Sections["Client"];

bool installChrome;
section.Keys["Install.Browser.Chrome"].TryParseValue(out installChrome);

bool installJava;
section.Keys["Install.Java"].TryParseValue(out installJava);

Console.WriteLine(installChrome);
Console.WriteLine(installJava);