Imagine I’ve got some “metadata” that describes some functionality of my system, e.g. the command line parameters to a tool:
<args description=“Two wrongs don’t make a right, but three lefts do”>
<arg name=“lefts” description=“Number of left turns” type=“int” default=4″ />
<arg name=“attitude” description=“Driver attitude” required=“true” type=“string” />
</args>
Once I have this “metadata” in place, should I a) use it to generate a class at compile-time that implements the command line parsing, or should I b) use it to drive a command-line parsing framework at run-time?
If I do a), generate the code, the result might look like this:
class Args {
public void Parse(string[] args) {…}
public string Usage { get {…} }
public int Lefts { get {…} set {…} }
public string Attitude { get {…} set {…} }
}
I’ve got better perf, but I have to generate the code in some way and .NET doesn’t come with any built-in tools to do that (no, I don’t count ASP.NET or XSLT as good codegen tools). Plus, the command-line args are now baked in and require a re-compile to change and who cares about perf to parse the command line? Finally, I’m much more likely to have most of the work done in a base class, e.g.
class Args : ArgsBase {
public void Parse(string[] args) { return base.Parse(args, …); }
public string Usage { get {…} }
public int Lefts { get {…} set {…} }
public string Attitude { get {…} set {…} }
}
In my experience, most of the work of code-gen is generating the smallest possible bit of code to provide a nice wrapper around a base class that does most of the work in a very interpretive manner.
If I do b), have a run-time interpretter of the “metadata,” I’ve got to build a command-line argument interpreter, but, as I’ve said, you almost always have that anyway. However, I also give up a develop-time wrapper aka “Intellicrack” which will be pried from my cold, dead fingers.
What do you guys do?
