[Profoundly Esoteric Image]

Maintenance-Free Mocking for Unit Testing with EntityFramework 4.0

GarethJ — Sat, 21 Aug 2010 05:23:26 GMT

Rab Hallett has a nice tool in the VS Gallery that uses T4 templates to generate mocks for unit-testing EF-based applications

Maintenance-Free Mocking for Unit Testing with EntityFramework 4.0

Technorati Tags: T4,Entity Framework,Unit Testing,Mock Objects

Visualization and Modeling Feature Pack with T4 Code Generation

GarethJ — Tue, 08 Jun 2010 00:26:03 GMT

As Jason Zander and Cameron have announced, we've just released the first Feature Pack for Visual Studio 2010, the Visualization and Modeling Feature Pack.

This pack is available to all MSDN subscribers and among a host of other great features, adds T4-based code generation to our UML static class diagrams.

This add-in works with the C# profile that we shipped with Visual Studio to generate code.

It's a great example of how you can rather easily build a profile yourself to add yet more metadata to your UML model and enrich the code generation further.

You can find all the detail on editing and customizing the templates here: http://msdn.microsoft.com/library/ff657795.aspx

Enjoy.

Technorati Tags: Visual Studio,T4,UML,Code Generation

What's new in T4 in Visual Studio 2010

GarethJ — Thu, 15 Apr 2010 08:54:22 GMT

OK, Visual Studio 2010 is well and truly released, so I thought I'd better catalog what goodness is in the box for all you T4 fans out there..

For template authors:

Preprocessed templates to allow embedding of template-based generation in arbitrary applications without a runtime T4 dependency. There is a new custom tool, new service APIs and new engine APIs to support this feature.
Runtime error handling is improved, with better handling of null expression blocks and fewer exceptions being eaten.
Include directives and Assembly directives now support both Windows environment variables and VS Macro variables.
Include directives and Assembly directives now resolved from VSIX Visual Studio extensions downloaded from VS gallery.
Include directives are now also resolved relative to the file that they are declared in to support libraries with relative includes.
Templates always use C#/VB 4.0 and .Net 4.0 types - language version is no longer needed.
Project/Add item templates for C# and VB and Web projects for both regular and preprocessed templates.
T4 now works in Web Site projects.
Generate All Files only runs the T4 custom tools in your project, not arbitrary ones like WPF.
The service tag project stamp is no longer written willy-nilly by T4.
New CompilerOptions flag to the template directive allows arbitrary flags to be sent to the template compiler, allowing optionstrict, optioninfer, optionexplicit etc. to be set for VB.
VS's Custom Tool Namespace is available in CallContext with the tag "NamespaceHint".
Templates no longer support the neutral culture, rather they always go to the invariant culture.
T4-MsBuild to transform your templates at build time.
The parser requires that templates with a class feature block finish with a class feature block to avoid boilerplate write statements hanging free at the end of the class causing hard-to-debug errors.
T4's assembly set is completely separated from the containing project's assembly set to avoid picking up the wrong assemblies when a project targets previous framework versions. Project assemblies are no longer used to resolve template assembly directives.
Assembly references will resolve from Visual Studio's PublicAssemblies folder.
WindowsBase.dll automatically referenced from templates.
Ability to use VS MEF components in the T4 AppDomain - also new CompositionServices helper class to make setting this up simple.
The options page is fully localized.
Better error messages when templates are included from internet zones or downloaded templates are included.
The Generate All Files button is disabled while a build is in progress so there aren't any clashes.

For custom tool builders:

Hosts can implement ITextTemplatingSessionHost to signal to the engine that they can provide a dictionary of arbitrary user data for the lifetime of the processing session. The data is accessed via a new Session property on the TextTransformation base class.
The built-in VS host implements ITextTemplatingSessionHost and provides a default session implementation to pass data from custom tools into templates while they run in the secondary appdomain, including resolving any necessary assemblies.
New "Parameter" directive with Name and Type properties, similar to the one in the GAX host. This allows custom tools to pass data to templates in a standard way. It resolves from the Session dictionary, the Host via ResolveParameterValue or the CallContext.
T4 interfaces have been split out into a separate assembly to facilitate longer term versioning without taking a dependency on T4's implementation assemblies.
RequiresProvidesDirectiveProcessor uses a new order for processing required parameters to support richer overriding.
BaseCodeGeneratorWithSite now exposes both GlobalServiceProvider and SiteServiceProvider members.
New base class BaseTemplatedCodeGenerator makes it even simpler to create a T4-based custom tool with one override.
ProvideCodeGeneratorExtension attribute makes it easy to hook up custom tools to the web site project system.
Public access to the CacheAssembliesOptionsString in the Engine class to help control caching without magic strings.
Directive Processors support IRecognizeHostSpecific interface to participate in decisions around forcing this flag on.
The correct system implementation of IVsSingleFileGenerator is used rather than a T4 internal one.
Access to the internals of the Visual Studio built-in host via ITextTemplatingComponents service interface.

For DSL Tools users:

ModelBus support in templates.

Phew, that's a long list - you can see that Visual Studio 2010 is a big release for T4.

I'll come back and edit this post to include live links as I fill in more details about some of these topics.

Technorati Tags: T4,Visual Studio 2010,What's New,Text Templating

Oleg on T4-MSBuild Integration

GarethJ — Wed, 14 Apr 2010 07:28:07 GMT

The newly released Visualization and Modeling SDK for Visual Studio 2010 includes support for integrating T4 with msbuild. (yay!)

The ever-diligent Oleg Sych has the full skinny here.

Technorati Tags: T4,msbuild,Visual Studio 2010

Bending T4 to be a textual DSL host

GarethJ — Thu, 11 Mar 2010 10:10:52 GMT

The estimable MVP and T4 enthusiast, Kathleen Dollard has a new post where she's using T4's ability to spit arbitrary text as a host for a textual DSL.

She's set up a small DSL for describing contract interfaces for a MEF framework:

         new Interface()

            Name = "ISearchModelBase",

            Scope = Scope.Public,

            CompositionInfo =

               new Property() {Name="TargetType", PropertyType="Type"}

},

            Members =

               new Property() {Name="DisplayName", PropertyType="string"},

               new Property() {Name="DataName", PropertyType="string"}

         }.Output()

Hosting this in T4 with a couple of lines of wrapper code spits out the following output, codifying her standard implementation pattern for MEF contracts and custom attributes:

Option Strict On

Option Explicit On

Option Infer On

Imports System

Imports System.Collections.Generic

Imports System.Linq

Imports System.ComponentModel.Composition

public Interface ISearchModelBase

   Property DisplayName As string

   Property DataName As string

End Interface

public Interface ISearchModelBaseComposition

   Readonly Property TargetType As Type

End Interface

< MetadataAttribute() > _

< AttributeUsage(AttributeTargets.Class, AllowMultiple:=False) > _

public Class SearchModelBaseAttribute

   Inherits ExportAttribute

   Implements ISearchModelBaseComposition

   Public Sub New( ByVal targetType As Type)

      MyBase.New(GetType(ISearchModelBase))

      _targetType = targetType

   End Sub

   Private _targetType As Type

   Public Readonly Property TargetType As Type Implements ISearchModelBaseComposition.TargetType

Get

         Return _targetType

      End Get

   End Property

End Class

Fascinating stuff, especially when you see that these days, populating such a structure in C#4.0 is such a snap with the new initializer syntax.

Peeking under the covers, at the attachment to Kathleen's blog entry, the code combines the DSL structure definition with the code output for VB in a way that's a bit too printf-ish for my personal taste, so I was tempted to T4 it up a bit.

The original template passes a StringBuilder down the call tree and builds code using AppendLine():

 private void AppendOpen(System.Text.StringBuilder sb)

         sb.AppendLine("Option Strict On");

         sb.AppendLine("Option Explicit On");

         sb.AppendLine("Option Infer On");

         sb.AppendLine("");

         sb.AppendLine("Imports System");

         sb.AppendLine("Imports System.Collections.Generic");

         sb.AppendLine("Imports System.Linq");

         sb.AppendLine("Imports System.ComponentModel.Composition");

Instead of this, I wanted to use regular T4 syntax with a class feature block:

      private void AppendOpen()

#>

Option Strict On

Option Explicit On

Option Infer On

Imports System

Imports System.Collections.Generic

Imports System.Linq

Imports System.ComponentModel.Composition

<#+

However, this code is inside a nested class, so the underlying Write statements needed by T4 aren't present. To get around this, I whipped up a trivial base class that supplies all of the necessary plumbing for T4 to be happy. This works because this part of T4 doesn't rely on a specific type, rather it just expects access to the members it needs and any class will do. In my implementation I simply delegate all of the calls back out to the main T4 template.

The only changes necessary to the DSL definition classes are to derive from my DslBase class and to add a trivial constructor to supply the main template to each DSL class instantiation:

public class Interface : DslBase

    public Interface(Microsoft.VisualStudio.TextTemplating.TextTransformation outer) : base(outer)

I've attached the base class code and a modified version of Kathleen's template for you to play with here. Enjoy.

Technorati Tags: T4,Textual DSL

Peter on UML Tools Extensibility

GarethJ — Tue, 27 Oct 2009 18:56:23 GMT

My esteemed colleague Peter Provost – whom I consistently fail to convince that I’m not into process engineering ;-) - has the first in what I’m sure will be a very informative series on extending the UML designers in Visual Studio 2010 Ultimate Edition

Technorati Tags: UML,Visual Studio 2010,Ultimate Edition

DTE and T4 - Better Together

GarethJ — Fri, 25 Sep 2009 21:27:57 GMT

A couple of folks out there have put together some really neat T4 templates that use the host-specific flag and then access Visual Studio's DTE object model to read state from other code in the project and use that as metadata for code generation.

Daniel Vaughan started out with a nice post on using DTE to explore the source constructs within your project using the CodeModel and thence using that data to introduce compile time strong-typing to WPF binding expressions.

To borrow Daniel's example, to switch from this weakly typed case

<StackPanel DataContext="{Binding Source={StaticResource Person}}">
    <TextBlock >Name:</TextBlock>
    <TextBox Text="{Binding Name}" />
</StackPanel>

to this strongly typed one which gives compile-time errors if you get the name wrong

<StackPanel DataContext="{Binding Source={StaticResource Person}}">
	<TextBlock >Name:</TextBlock>
	<TextBox Text="{Binding Path={x:Static Metadata:PersonMetadata.NamePath}}"/>
</StackPanel>

He then also talks about using the same technique to generate implementations of INotifyPropertyChange that are robust to refactoring without the problems of embedded strings or the performance hit of reflection. Code generation and declarative programming are often criticized for not having good support for refactoring, so it's nice to see a use case that actually helps support refactoring.

Daniel has now expanded this into a full article on The Code Project.

Last time, I talked about Colin Eberhardt's article for generating Dependency Properties from an xml file. Daniel's approach inspired Colin to go back and rework his example to use DTE replacing his external XML file with custom attributes on classes to simply add dependency properties like so:

[DependencyPropertyDecl("Maximum", typeof(double), 0.0)]
[DependencyPropertyDecl("Minimum", typeof(double), 0.0)]
public partial class RangeControl : UserControl
{
    ...
}

Very cool stuff.

Technorati Tags: T4,DTE,Visual Studio 2008,Code Generation,Dependecy Property,Databinding,Strongly-typed

T4 and Silverlight in Visual Studio 2008

GarethJ — Fri, 25 Sep 2009 20:32:23 GMT

Colin Eberhardt has a nice article on The Code Project walking through using a small textual DSL encoded in XML to define a set of dependency properties and then using that as a data source for T4 to generate all of the necessary boilerplate code.

Apart from being intrinsically cool, he's also doing this in a Silverlight project, and he includes the small amount of special sauce needed to get T4 generation working in a Silverlight project inside Visual Studio 2008.

BTW, in Visual Studio 2010, T4 in Silverlight should "just work".

Technorati Tags: T4,SIlverlight,Visual Studio,Visual Studio 2008,Dependecy Property

ASP.Net MVC T4 Updates

GarethJ — Fri, 25 Sep 2009 08:13:23 GMT

Couple of newsworthy T4 links for the wildly popular ASP.Net MVC framework.

This one is from July but I hadn't spotted it - David Ebbo has a new version of his T4MVC set of templates for view generation.

Space Invader Zim (nice name) has a walkthrough of an extension to the standard templates that he's been working on.

Technorati Tags: T4,ASP.NET MVC,Visual Studio,Code Gen

Peter Vogel on Code Generation

GarethJ — Fri, 25 Sep 2009 08:06:44 GMT

There's a fun interview with Peter Vogel on the subject of Code Gen on the ever-popular .NET Rocks talkshow. He's got a new code gen book coming out and in the interview he says he's going to have an "expansion pack" for the book to cover T4. Can't wait for that.

You can find the audio here and a transcript here.

Technorati Tags: Code Generation,T4,Visual Studio,.NET Rocks

T4 Templates for SharePoint

GarethJ — Fri, 25 Sep 2009 06:56:59 GMT

For all you SharePoint heads out there,

Waldek Mastykarz has a couple of neat articles on generating some of the various config files that control a SharePoint instance using T4:

Visual Studio T4 template for SharePoint Solution (DDF)

Visual Studio T4 template for SharePoint Feature Definition (Feature.xml)

Generate your own SPBuiltInFieldId class

Enjoy

Technorati Tags: Sharepoint,T4,Visual Studio,Code Generation

WPF, DSL in Visual Studio 2008

GarethJ — Thu, 24 Sep 2009 05:07:44 GMT

Although data-binding to WPF is a feature of DSL Tools in Visual Studio 2010, that hasn’t stopped our vibrant community from hacking away to get results today with VS2008.

Have a look at this selection of posts:

Using WPF As The Designer Surface In DSL Tools

Provide an improved user experience to your DSL's

Both of these use a naked objects style of approach which is pretty similar to what we’re building in to the core libraries in 2010.

The last one is more appropriate for complex UI’s that don’t represent you domain model so directly and proposes putting a viewmodel in front of your model.

How to bridge the gap between DSL tools store and the WPF DataBinding system

Technorati Tags: DSL Tools,WPF,Visual Studio,VSX,Databinding

Tangible T4 Editor

GarethJ — Sat, 23 May 2009 08:30:26 GMT

I've been remiss generally in not blogging while we've been heads down on Visual Studio Beta1, but never more so than in respect of another T4 Editor that's recently become available.

The good folks over at Tangible Engineering have been releasing several versions of their T4 Editor for Visual Studio 2008 and now have released a shiny version for Visual Studio 2010 Beta1. How's that for speedy?

Under Visual Studio 2010 Beta1, you can find this T4 Editor by simply going to the new Extension Manager (find it under the Tools menu)

So for all you T4 fiends, you now have a choice of editors (in strictly alphabetical order)

	Visual Studio 2010 Beta1	Visual Studio 2008	Visual Studio 2005
Clarius Consulting	Soon, I'm sure. ;-)	Get it	Get it
Tangible Engineering	Get it	Get it

Keep on transforming those templates.

Technorati Tags: T4Editor, Tangible Engineering, Clarius Consulting

DSL Tools 2010 Beta1 Launches!

GarethJ — Sat, 23 May 2009 06:37:25 GMT

Jean-Marc announced today that the latest new beta version of DSL Tools launched today hot on the heels of the recent Visual Studio 2010 and Visual Studio 2010 SDK beta releases.

The team is really proud of all the great features we're shipping in this release. I hope you enjoy them too. From Jean-Marc's blog:

Different models can now interact with each other, (and with Visual Studio Team System Architecture UML designers), using the ModelBus. A DSL author can choose to generate a ModelBus adapter, that will expose his model to other models or tools.
Databinding support has been added, allowing Windows.Forms and WPF form-based designers to be created by binding a standard winform or WPF-based UI directly to DSL models. This enables developers to quickly create designers such as the .ResX or .settings designers in Visual Studio.
It is now possible to have completely or partially read only models, which can be used for instance by reviewing and commenting tools.
A number of UI enhancements have been added, including :

moveable labels for connectors,
sticky toolbox (when the user double-clicks on an item in the toolbox,it's not necessary to return to the toolbox for repeated applications of the tool),
quick navigation and editing of compartments with the keyboard
Copy and paste of diagram elements to images (in Bitmap and .wmf/emf)
Copy and paste of model elements in or between diagrams

The notion of DslLibrary has been introduced. This enables factorizing and componentizing DSLs (for instance having several domain models have the same base-domain class). The authoring for this feature will not be present in Beta1
The DSLs can now be extended by third parties after they have deployment. The authoring for this feature will not be present in Beta1

Check out the Code Gallery page for samples and beta docs.

I'll start to list out in more detail the new T4 features after I get my breath back a bit. :-)

Technorati Tags: DSL Tools, Visual Studio, 2010, Annouce

Customizing Generated Resources in DSL Tools

GarethJ — Sat, 23 May 2009 06:15:30 GMT

Most of the code we generate with DSL Tools is pretty agnostic about its location or the filename you use for the template or the generated output.

The one exception to this is the generated resource file (usually a pair called DomainModelResx.tt/DomainModelResx.resx)

The reason this puppy is a little more sensitive is that the output resx is generated as item with a compile type of Embedded Resource in the Dsl csharp project that it lives in.

This causes the project system to pick up the relative path from the project root to the resx file and use that to form the Id that is used to embed the resource into the assembly.

Naturally, we also have to reference the resource at runtime in order to make use of its contents and to do that, we need to encode its Id at the point of use. This happens to be in the DomainModel.tt/DomainModel.cs pair.

What this means is that we have to provide some logic for generating that resource Id in our T4 templates as there isn't an API in Visual Studio to get hold of it :-(

Rather than trying to be too clever, we just use a simple scheme that expects the resource to be in the default GeneratedCode folder structure.

OK, that's all a bit abstract, so here's an example.

Given a normal folder structure like this:

You'll get a resource created like this:

You can see that the GeneratedCode folder name has been encoded into the resource Id.

We'll match that in the generated DomainModel.cs file with the following snippet

   1: /// <summary>

   2: /// The base name of this model's resources.

   3: /// </summary>

   4: public const string ResourceBaseName = "MicrosoftCorp.DemoLanguage.GeneratedCode.DomainModelResx";

So now suppose you go and rearrange your DSL project and now there's an intermediate directory called Dummy? And how about you also rename the template and generated file to be simply DslResources.tt/resx?

You'll get an embedded resource like this.

So far, this is all just regular VS stuff and not much to do with DSL Tools, but if we peek into DomainModel.tt/.cs, we'll see that the generated code has no idea that it has been moved and doesn't change that ResourceBaseName constant.

So how do we fix it up? We wouldn't leave you in the lurch now would we? No, of course not.

As an aside, we've done some work in DSL 2010 to let that directory change peek through into the template, but that doesn't help with the resource file name change.

To allow fine-grained control over matching the generated code path and resource name, we added three optional parameters to the DSL directive processor used in DSL Tools' .tt files:

GeneratedCodeFolder: allow you to specify the folder relative to the project root where the generated resources live.
GeneratedResourceFile: allows you to specify the filename for the resource base name
ProjectDefaultNamespace: allows you to override the project file's default namespace as the starting point of the resource base name

Here's an example of using the first two to match up our project changes

<#@ Dsl processor="DslDirectiveProcessor"  requires="fileName='..\DslDefinition.dsl';GeneratedCodeFolder='Dummy.GeneratedCode';GeneratedResourceFile='DslResources'" #>

We simply catenate the three values to form the overall base name, but keeping them separate allows us to reuse them in other scenarios. Here's the result, which matches the actual embedded resource:

   1: /// <summary>

   2: /// The base name of this model's resources.

   3: /// </summary>

   4: public const string ResourceBaseName = "MicrosoftCorp.DemoLanguage.Dummy.GeneratedCode.DslResources";

These extra parameters are pretty undiscoverable options on the DSL directive processor, so I hope this tip helps someone out. It's also a good example of how you can easily expand the directive processor we generate for you with your own DSL. These three parameters were all added purely additively in a partial class next to the generated code for the dsl directive processor. (Yes, we do generate the dsl directive processor that you use for parsing dsls to generate the directive processors for other dsls :-) )

Have fun rearranging your projects.

Technorati Tags: DSL Tools, DirectiveProcessor, Resources, ResX

Software Factories Redux

GarethJ — Sat, 28 Feb 2009 21:09:27 GMT

Don has a great post on where the p&p team are going with Software Factories and GAT/GAX.

No doubt we'll be talking to those good folks about how they can take advantage of new features in DSL 2010 in their 2010 versions of Factories.

Technorati Tags: Software Factories, VSX, T4, DSL Tools

TellMe Voice Studio Beta1

GarethJ — Fri, 06 Feb 2009 11:58:29 GMT

I just noticed that the good folks over at TellMe (a relatively new bit of Microsoft) have shipped a beta of their Voice Studio voice application dev tool, based on DSL Tools. Very cool indeed! (I seem to be saying this a lot lately)

I love the process of developing voice apps - One of the last things I did in Microsoft before joining Visual Studio was to build a voice-enabled kiosk for helping folks access local government services. It was seriously rewarding when you managed to have testers use a natural seeming set of sentences to get something done. There's just a certain Star Trek magic to the whole process.

I think part of me may end up getting a similar buzz from extracting structured data from textual DSLs - MGrammar crossed with text extraction maybe - be interesting to go the same route as voice and have a confidence match for the textual DSL and then have a process of refinement from relatively vague textual musings to specific textual models.

Many congrats to the TellMe team (or as I'm steadily learning the colloquialisms over here, GO TellMe!)

Technorati Tags: VSX, DSL Tools, Speech, TellMe, Visual Studio

Clarius take T4 editing to the next level

GarethJ — Thu, 05 Feb 2009 01:23:33 GMT

I see that Clarius have now got to an alpha stage for the next stage of their T4 editing toolset.

As well as their Community Edition and Pro Edition, they're now going to offer a full-featured code generation environment they're calling Visual T4 Code Generator, including tight integration with server explorer, database tables and XML as well as a multi-file generation implementation out of the box and lots more beside.

Here's a short video of their database support:

Once again, very nice indeed.

Technorati Tags: T4, T4Editor, Clarius, Visual Studio

More on T4 in ASP.Net MVC

GarethJ — Thu, 05 Feb 2009 01:08:47 GMT

Abhishek from the MVC team has just posted some detailed instructions on using the new T4 customization features in the ASP.Net MVP release candidate

Very cool.

Technorati Tags: T4, ASP.Net MVC, Code generation, Visual Studio

T4 Adoption continues with ASP.Net MVC Tools

GarethJ — Tue, 13 Jan 2009 02:52:27 GMT

Ok, the big guns are pitching in now :-)

Hot on the heels of the tooling for LINQ-to-Entities folks adopting T4 for their next release, comes another.

Scott Guthrie just blogged about a new RC of ASP.Net MVC that will shortly be coming along. It's a long post, but down in the section on view templates in the scaffolding system, he mentions that they use T4 as a one-time generation technology to set these up based on your data.

Of course, this means that the generation is fully customizable.

I'm seeing the beginnings of a trend where product groups are finding they can get often-requested features for code generation customization by going the T4 route rather than hardcoding CodeDOM trees or some other tough to modify solution.

All isn't perfect, as of course this type of customizatio tends to require comparison of product and user templates when new versions of things come out. See Oleg's excellent encapsulation techniques (Nested Template Class especially) for ways to mitigate that.

Technorati Tags: T4,Visual Studio,Code Generation,Text Templating

T4 Interview in Redmond Developer News

GarethJ — Fri, 09 Jan 2009 04:53:31 GMT

A couple of months ago, John K. Waters of Redmond Developer News was kind enough to interview Rob Conery and I about T4 and code generation in general.

You can find the results here.

Technorati Tags: T4,Code Generaton,Text Templating,Visual Studio

DSL 2010 Feature Dives: T4 Preprocessing - Part Two - Basic Design

GarethJ — Wed, 12 Nov 2008 03:38:00 GMT

Lat time we looked at the "WHy" of T4 preprocessing - now let's look at an overview of the how.

To explain the new features, it's helpful to have a look at the current way data flows through T4 2008. Let's suppose you have a trivial template generating some trivial output:

Now to get from the template to it's output, the T4 engine goes through three stages:

In the first, Preprocess stage, the template is parsed into a series of blocks, any directives found within it are acted on (for example, to set the output extension or to include a sub-template) and then a "Template class" is generated that represents code to produce the final output of the template. In this case, the template class would look something like the following (I've simplified a bit):

T4 supplies the base class TextTransformation, which contains the Write family of helpers which simply write to a StringBuilder exposed by the GenerationEnvironment property.

The second stage takes the text of this class and compiles it using the CodeDOM to produce a temporary assembly.

The third stage loads the temp assembly, creates an instance of the Transform class and calls the TransformText method on it to produce the final output of the template.

So that's what happens at present. What do we need to change if we want to run the template in arbitrary applications?

Firstly, we need to split up the stages. Indeed, if the template is going to be built as part of some application, T4 doesn't need to get involved in stage two at all - the user will presumably have their build environment set up for compiling and deploying application code and the template class will now just become part of that code. So we'll need new APIs and tools for Stage One that return the code for the template class, and we can ignore Stage Two.

For Stage Three, the host application will need to run the template. Clearly it can just call the TransformText method as it has a trivial API - although it may have to do so via reflection if the set of templates is in any way dynamic as there is no interface implemented here, just a standard signature. (Actually, the new dynamic feature in C# 4.0 should make this a breeze). However, this tells us we'll need a way for the new Stage One API to specify more detail (such as the name and namespace) about the template class to be generated.

Finally for stage three, the base class, TextTransformation, becomes a problem. This class lives in the T4 assembly, which only ships in Visual Studio, so you will likely not have it available in your deployment environment. Luckily the contents of this base class are rather trivial helper methods on the whole. To address this, if you don't specify a base class, we'll make T4 generate the helpers directly into your template class, relieving you of the dependency. Alternatively, it's pretty easy to add a set of helpers to any base class that you add to your own deployable code, so long as they fulfill the signature that the template class needs.

Next time we'll go into detail on what APIs will be available and then fill in some details where I've oversimplified in this explanation.

Technorati Tags: T4, DSL Tools, Domain-Specific Language, Code Generation, Visual Studio 2010

DSL 2010 Feature Dives: T4 Preprocessing - Part One - Rationale

GarethJ — Wed, 12 Nov 2008 01:03:00 GMT

Strictly, this isn't a DSL 2010 feature, but a general Visual Studio 2010 feature; T4 is only coupled organizationally to DSL Tools, not technically, but it fits into our current announcements, so I won't worry about that too much.

Over the last year or so, I've been fielding an increasing number of requests from folks who want to use T4 to produce output in scenarios other than at design-time inside Visual Studio. Just to be clear, T4 in its 2008 incarnation is not suitable for use on the server, or in any concurrent, multi-threaded scenario - there's nothing specifically wrong with the code in this regard that we know of, but it's simply not tested in this arena, and we choose not to support something that hasn't been tested. T4 also only ships inside Visual Studio SKUs, so you have some unfortunate installation and interpretation of your EULA to do if you wanted to look at using it in another scenario.

However, we're very aware of this pent-up demand, and a conversation with the Entity Framework team brought our thinking caps out.

What we came up with was an assertion that want something like the following:

In a high percentage of scenarios for using T4 at runtime (as opposed to design-time), the template only changes as part of a software installation; rather the input data for the template is changing in order to produce differing output.

For example, you can imagine T4 being used to implement some transform between EDI data and XML data in a business workflow. It's likely that the structure of the required XML document is an implementation artifact of the workflow, whereas clearly the instance documents of the XML are directly driven by the instance of EDI data that's presented.

On this basis, we realized that if we decoupled T4's preprocessing stage from its compile and run stages, we could produce template code that could repeatably take input and produce template output that we'd be happy to support running in any .Net environment, thus enabling a lot of the scenarios that customers had asked for.

We call this feature Template Preprocessing and next time I'll describe the high level design points.

Technorati Tags: T4, DSL Tools, Domain-Specific Language, Code Generation, Visual Studio 2010

Nice step-by-step on adding a menu to DSL Tools 2008

GarethJ — Wed, 12 Nov 2008 00:12:17 GMT

Sebastian Talamoni has a nice guide to adding a menu using a vsct file.

Technorati Tags: DSL Tools, VSX

New DSL Tools lab

GarethJ — Tue, 11 Nov 2008 23:51:45 GMT

Jean-Marc has just released a complete walkthrough of DSL Tools for Visual Studio 2008 aimed at DSL beginners as a lab on CodeGallery.

Here you can see the language from the lab designing mouse gestures for manipulating primitives in a simple graphics program.

Very nice indeed.

Technorati Tags: DSL Tools, Modeling, Hands-on lab, Domain-Specific Language