Configuration is a scripting task.
Since I am fed up with the bracket mess of mono/.NET web apps, I was thinking about a more convenient configuration system. Most configuration systems lack flexibility, because they just evaluate a static file and set some values. Some allow for includes, but not much more. But advanced applications need more flexibility, in other words: code. If the config file is a script and has access to the application, then you have all the flexibility you need, and type safety.
And what is the most natural config script language for a C# project? C#, of course.
All you need is a script engine like CS-Script. Add the script engine, create a script host, load the config script file on application start and execute it. The best part is, that the configuration file is type safe and can be edited by the usual development system.
Here are my code bits:
Add the CSScriptLibrary.dll to the project References.
Create a class that implements the script file loader: ScriptedConfig.cs
using System;A class that implements my specific configuration object derived from ScriptedConfig: MyConfig.cs:
namespace MyApp
{
public class ScriptedConfig : MarshalByRefObject
{
public string BasePath { get; set; }
public void Include(string sFile)
{
using (CSScriptLibrary.AsmHelper helper =
new CSScriptLibrary.AsmHelper(CSScriptLibrary.CSScript.Load(
BasePath + sFile, null, true)))
{
helper.Invoke("*.Configure", this);
}
}
}
}
using System;The application startup code:
using System.Collections.Generic; // just for the sample Dictionary
namespace MyApp
{
public class MyConfig : ScriptedConfig
{
// Just some sample values
public string sText1_ = "empty1";
public string sText2_ = "empty2";
// A sample dictionary to hold more values
public Dictionary<string, string> values_ = new Dictionary<string, string>();
public Dictionary<string, string> Values { get { return values_; } }
public string Text2 { get { return sText2_; } }
}
}
I have a global config file, that is the same for all installations and a local config file that overrides the global setting for the test syste, the stage system or the production system. This is the ConfigGlobal.cs:
MyConfig myconfig = new MyConfig ();
myconfig.BasePath = AppDomain.CurrentDomain.BaseDirectory; // For my web app
myconfig.Include("ConfigGlobal.cs");
using System;The global config file invokes the local config file, which configures the same object. ConfigLocal.cs:
using MyApp;
public class Script
{
public static void Configure(MyConfig c)
{
c.sText1_ = "Global Config 1";
c.sText2_ = "Global Config 2";
c.Include("ConfigLocal.cs");
}
}
using System;You access the config values like:
using MyApp;
public class Script
{
public static void Configure(MyConfig c)
{
c.sText2_ = "Local Config 2";
c.values_["Text3"] = "Local Config 3";
}
}
Actually, in my current project I separate my code from the implementation of MyConfig by a facade pattern using an interface (IConfig) and in addition access the config instance via StructureMap and a global static wrapper (Config).
string t1 = myconfig.sText1_;
string t2 = myconfig.Text2;
It rather looks like:
But that's for later.
string t1 = Config.Get("Text1", "Default1");
string t3 = Config.Instance().Values["Text3"];
_happy_configuring()
