I previously wrote about some experiences I have had with T4 templates and generating objects from database tables using the MSSQL metadata tables. Well another code generation opportunity came up and a comment by a reader pointed me in the direction of Damian Guard’s Manager.tt template so I decided to take a look. Nothing wrong with using something better than what you’ve already developed.
First up, a couple of observations with T4 and VS2010 (my previous experience with T4 in my post was using VS2008 and it would interesting to see how far T4 and IDE have come along).
“Save” Means “Execute”…Still!
The first thing I have noticed, which I was hoping would have changed, was the generation model/compilation model: when ever you hit Ctrl S, the template will save and immediately be run by the T4 engine. The problem with this is that if your doing a bunch of refactoring and if your work flow is modify/save/build (such as mine is, I blame TDD) then you’ll quickly slow down as the code generated that doesn’t compile will muck up VS. For example if you are generating a lot of files, things slow down to a stop if this happens after every save. I think it would be so much nicer if it was tied into it’s own command (such as in the Build dropdown) and instead of piggy-backing on “Save”.
Always Set debug=true!
This is super important -- always set debug to “true” on your template headers:
Doing this is the difference between pulling your hair out trying to figure what is failing and quickly fixing the issue and moving along
Assembly Locking is Major PITA: Use VolatileAssembly Directive from the T4 Toolbox!
Note: Apparently this is resolved in VS2010 SP1 (Thanks Will!)
One thing that you’ll quickly discover if your calling into code that exists outside of the template (such as the assembly that you are creating your templates in) is that the T4 engine will reuse the assemblies used by the templates, thus they will remain blocked while the engine is running. What this means is that you will have to close VS and reopen it if you want to modify the code in those assemblies (such as when you discover an issue in the code the template is using to generate your output).
Closing and Reopening Visual Studio is a major PITA and seriously cuts into your productivity. Fortunately, there is a workaround: download and install the T4 Toolbox from CodePlex.com and use the VolatileAssembly directive on one and only one template.
What this does is create a temporary copy of the referenced assembly for each template generation which is cleaned up after the generation completes.
Damien Guards Manager.tt Template Rocks!
Now for the grand finale: Damien Guards Manager.tt is awesome and really makes multi-file code generation easy. For details, check out his blog posting from the references below, but here is quick overview:
Here is a breakdown of what is going on:
- Include Damien’s Manager.tt T4 template
- Create a reference to the T4 generation environment
- Start a new file using StartNewFile(string fileName). The file’s body is created between this method call and the next EndBlock()
- EndBlock() stops the generation of the file’s body
- StartHeader() starts a new header section
- EndBlock() ends the header section
- Call Process() to generate the files
It’s really pretty straightforward and easy to use.