XML Driven C#/T4 Code Generation with ElasticObject Nuget Package For Minimalists ;)


ANOOP MADHUSUDANAN

Vote on HN

imageCode generation should be simple, and I wanted to do it by using a simple XML file as my model from with in Visual Studio. So, here is a quick wrapper I’ve created for Xml driven code generation for minimalists/minimal scenarios.

Starting Super Simple XML driven code generation – Now with Nuget

Here we go – this is based on my ElasticObject implementation to generate code using Text Templates (TT/T4), by using simple XML files as a model. It is so simple that it won’t support the entire XML schema Winking smile -  But I’ll live with that for now. So, the steps are simple.

imageStep 1 - Get the ElasticObject Nuget Package

Install AmazedSaint.ElasticObject, run the following command in the Package Manager Console

PM> Install-Package AmazedSaint.ElasticObject

Or you can install this via the Nuget Package manager, it is your choice.

Step 2 – Enjoy

This should add the reference to ElasticObject library, and will add an Xml model file and a T4 template in the Solution Explorer (See the image). The xml file can be your model, and the TT file has a bit of code that wraps the model for generating what ever you need (source code, views, scaffolding etc). You can modify the xml and the TT file. Also, there is a ReadMe-ElasticObject.cs.txt which you can re-name to  a CS file and view/run the tests to see the usage of ElasticObject.

What is in the Xml model file and TT generator?

The example model file contains some sample xml, it can be anything (infact, a reasonable subset of xml ;))

<model>
<class name="MyClass1">
  <property name="MyProperty1" type="string"/>
  <property name="MyProperty2" type="string"/>
</class>
  <class name="MyClass2">
    <property name="MyProperty1" type="string"/>
    <property name="MyProperty2" type="string"/>
  </class>
</model>

So, as you can see, the model can be anything, with in a valid root element. The example just mimics few classes and properties in that. Now, let us have a quick look at the example TT file added by the Nuget package. Don't get afraid, it is some simple T4 syntax - Refresh your T4 Skills from here, Oleg has everything for you to start with the T4 syntax (and much more).

Did I tell you you can use Visual T4 Editor Free edition to reduce the pain when you work with T4 Templates? Get it today from the VS Extensions gallery, otherwise you’ll end up sending hate mails to the guys who created the Visual Studio T4 editor.

In the below code, you could see that we are creating an elastic object from the xml, and then iterating the elements for generating the code – In case you are not familiar with ElasticObject, see my post here – It is just a wrapper dynamic object I created for loosely wrapping stuff like xml. Also, you could see this LIDNUG presentation where Shey is demoing the ElasticObject in between his dynamic talk.

Anyway, here is the T4 code you’ll find in the tt file added by our Nuget package.

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ Assembly Name="System.Xml.dll" #>
<#@ Assembly Name="System.Xml.Linq.dll" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ Assembly Name="Microsoft.CSharp.dll" #>
<#@ Assembly name="$(SolutionDir)packages\AmazedSaint.ElasticObject.1.0.0\lib\net40\AmazedSaint.Elastic.dll" #>
<#@ Import Namespace="System.Xml" #>
<#@ Import Namespace="System.Xml.Linq" #>
<#@ Import Namespace="AmazedSaint.Elastic" #>
<#@ Import Namespace="AmazedSaint.Elastic.Lib" #>
<#@ output extension=".cs" #>

<#
var model=FromFile("ElasticDemoModel.xml");

foreach(var c in model["class"])  //get all classes
	WriteClass(c);

#>

<#+ 
//Create an elastic object
private dynamic FromFile(string file)
{
   var path= Host.ResolvePath(file);
   return XDocument.Load(path).Root.ToElastic();
}

//Write a class
private void WriteClass(dynamic c)
{ 
#>
//Class generated 
class <#= c.name #> 
{
<#+
	foreach(var p in c["property"])
	   WriteProperty(p);  
#>			
}
<#+
}


//Write a Property
private void WriteProperty(dynamic p)
{
#>
public <#= p.type #> <#= p.name #>  {get;set;}
<#+   
}
#>

And you guessed it, the generated file is here.

//Class generated 
class MyClass1 
{
public string MyProperty1  {get;set;}
public string MyProperty2  {get;set;}			
}
//Class generated 
class MyClass2 
{
public string MyProperty1  {get;set;}
public string MyProperty2  {get;set;}			
}

Note that this requires C# dynamic support, and hence targets the .NET 4.0 runtime – So if you want to have code generation in other platforms with out dynamic support, add a .NET 4.0 project, keep your models and TT/T4s there, and add/link the generated files to other projects. This example just shows C# code generation from the model, but you can imagine what all things you can do Winking smile

Update: See an example implementation – CanML – Creating a simple markup language for drawing shapes to HTML5 Canvas

Few more of my previous posts, if you’ve more interest.

© 2012. All Rights Reserved. Amazedsaint.com