Les Templates T4

La T4 Toolbox est un peu le couteau suisse du Template T4 ! Elle apporte de nombreuses fonctionnalités qui pourront vous aider à la création de Templates T4 avancés. Une de ces fonctionnalités primordiales est à mon sens la possibilité de générer plusieurs fichiers depuis un seul Template T4.

Vous pouvez télécharger la T4 Toolbox ici : http://t4toolbox.codeplex.com/T4 Toolbox.

Tangible T4 Editor est un éditeur pour Templates T4. Il apporte principalement la coloration syntaxique, mais aussi l'autocomplétion. Il fournit aussi une galerie de Templates, très utile pour éviter de réinventer la roue.

Attention : Tangible T4 Editor est un logiciel payant. Une version gratuite est proposée, mais vous devrez faire face à quelques limitations : autocomplétion limitée à certaines assemblies, modélisation UML limitée. Pour le téléchargement, ça se passe ici : Tangible T4 Editor.

Visual T4 est un plugin pour Visual Studio qui apporte la coloration syntaxique, mais aussi l'autocomplétion. À la différence de Tangible T4 Editor, il est entièrement gratuit. Je vous conseille de comparer les deux et de prendre celui sur lequel vous êtes le plus à l'aise.

Le téléchargement se passe ici : Visual T4.

Les Templates T4 disposent d'une syntaxe qui leur est propre. Cette syntaxe ressemble à celle de l'ASP, et est donc facile à assimiler.

La première chose à savoir est que tout texte saisi hors balise se retrouvera au sein du fichier de sortie. Prenons l'exemple du Template T4 suivant :

<#@ template debug="true" hostspecific="false" language="C#" #>
<#@ output extension=".txt" encoding="UTF8" #>
Hello World !

Le résultat sera un simple fichier texte comprenant « Hello World ! ».

Un bloc de code s'insère de cette manière :

<#@ template debug="true" hostspecific="false" language="C#" #>
<#@ output extension=".txt" encoding="UTF8" #>
<#
String message = "Hello World !";
#>

Pour afficher une variable ou du texte issu d'un traitement :

<#@ template debug="true" hostspecific="false" language="C#" #>
<#@ output extension=".txt" encoding="UTF8" #>
<#
String message = "Hello World !";
#>
<#= message #>

Il existe un dernier type de bloc dans les Templates T4 : les class feature blocks. Ces blocs permettent de déclarer des classes et des méthodes utilisables dans votre Template T4. Ces blocs doivent toujours être déclarés en fin de votre Template T4 et s'utilisent de la manière suivante :

<#@ template debug="true" hostspecific="false" language="C#" #>
<#@ output extension=".txt" encoding="UTF8" #>

<#= ToUpper("Hello World !") #>

<#+

public string ToUpper(String message)
{
    return message.ToUpper();
}
#>

Pour faire un petit résumé, voici les différentes balises des Templates T4 :

• : directive ;
• : bloc de code ;
• : affichage de texte depuis du code ;
• : class feature blocks.

Les directives sont des informations à placer obligatoirement au début de votre Template T4. Elles permettent de spécifier le comportement de celui-ci. Elles se composent toutes de la même syntaxe :

<#@ DirectiveName [Attribute = "Value"] #>

III-B-1. Template▲

III-B-2. Output▲

<#@ output extension=".txt" #>

<#@ output extension=".txt" encoding="UTF8" #>

III-B-3. Assembly▲

<#@ assembly name="System.Data" #>

III-B-4. Import▲

<#@ import namespace="System.Data.SqlClient" #>

III-B-5. Include▲

<#@ include file="c:\Projects\T4\include1.tt" #>
<#@ include file="..\T4\include1.tt" #>

Maintenant que nous avons créé notre Template T4, nous allons l'exécuter pour lancer la génération de notre fichier de sortie. Plusieurs options s'offrent à nous :

• sauvegarder le fichier .tt : cette action lance automatiquement l'exécution du Template T4 ;
• clic droit sur notre fichier .tt : exécuter un outil personnalisé ;
• utiliser le bouton spécifique dans l'explorateur de solution (lance l'exécution de tous les Templates T4) : .

Notre solution va être simple : un projet de type « bibliothèque de classes », comprenant un dossier « classes » et notre Template T4 :

Dans un premier temps, nous allons modifier le type de sortie de notre Template T4 en fichier .cs, mais aussi importer le namespace System.IO :

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ import namespace="System.IO" #>

Une fois cette étape réalisée, nous allons créer des variables utiles au fonctionnement de notre Template T4 :

string NameClass = "ClassT4"; //nom de la classe générée par le template
string NameSpace = "T4Practice"; //Namespace de la classe générée
string folder = "Classes"; //Dossier contenant nos classes
DirectoryInfo directoryTemplate = new FileInfo(Host.TemplateFile).Directory; //répertoire contenant notre tt

Afin de rendre plus lisible le code de notre Template, nous allons le segmenter en plusieurs méthodes. La première sera chargée d'écrire les différents usings :

private void writeUsings(string space, string folder)
{
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using <#= space + "." + folder #>;

<#+ 
}

La dernière ligne sert à créer le using pour pouvoir disposer de nos classes. La prochaine fonction aura pour rôle d'écrire le namespace et la déclaration de la classe :

private void BeginHeader(string space, string nameClass)
{
    
#>
namespace <#=  space #>
{
    public class <#=  nameClass #>
    {
    
<#+ 
}

Cette fonction attend en paramètres le namespace et le nom de la classe. La troisième fonction servira à fermer les accolades à la fin de notre fichier :

private void EndNamespace()
{
#>
    }
}
<#+
}

Enfin, notre dernière fonction servira à écrire le code relatif à une propriété :

private void WriteProperty(string name)
{
#>
    public <#= String.Format("{0} {1}",name, name.ToLower()) #>  {get; set; }
    
<#+
}

Grâce à ces quatre méthodes, nous allons pouvoir générer notre Template T4. Nous allons maintenant ajouter le code permettant de parcourir les fichiers concernés. Pour commencer, déclarons quelques variables :

string NameClass = "ClassT4";
string NameSpace = "T4Practice";
string folder = "Classes";
DirectoryInfo directoryTemplate = new FileInfo(Host.TemplateFile).Directory;

• NameClass : nom de la classe générée par notre Template T4 ;
• NameSpace : espace de nom dans lequel doit se situer notre classe générée ;
• folder : nom du dossier contenant nos classes ;
• directoryTemplate : répertoire parent de notre Template.

Maintenant, il ne nous reste plus qu'à créer le code pour remplir notre fichier de sortie :

writeUsings(NameSpace, folder);

BeginHeader(NameSpace, NameClass);

foreach(FileInfo file in new DirectoryInfo(directoryTemplate.FullName + @"\" + folder).GetFiles())
{
    WriteProperty(file.Name.Split('.').GetValue(0).ToString());
}

EndNamespace();

1. On insère les différents usings ;
2. On insère le namespace et la déclaration de la classe ;
3. Pour chaque fichier du dossier, on va créer une propriété ;
4. On termine en fermant les différentes accolades.

Nous en avons donc fini avec notre Template. Voici le résultat obtenu en entier :

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ import namespace="System.IO" #>
<#  
string NameClass = "ClassT4";
string NameSpace = "T4Practice";
string folder = "Classes";
DirectoryInfo directoryTemplate = new FileInfo(Host.TemplateFile).Directory;

writeUsings(NameSpace, folder);

BeginHeader(NameSpace, NameClass);

foreach(FileInfo file in new DirectoryInfo(directoryTemplate.FullName + @"\" + folder).GetFiles())
{
    WriteProperty(file.Name.Split('.').GetValue(0).ToString());
}
EndNamespace();

#>

<#+ 
private void writeUsings(string space, string folder)
{
#>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using <#= space + "." + folder #>;

<#+ 
}

private void BeginHeader(string space, string nameClass)
{
    
#>
namespace <#=  space #>
{
    public class <#=  nameClass #>
    {
    
<#+ 
}

private void EndNamespace()
{
#>
    }
}
<#+
}

private void WriteProperty(string name)
{
#>
    public <#= String.Format("{0} {1}",name, name.ToLower()) #>  {get; set; }
    
<#+
}

#>

Lorsque nous exécutons notre Template, nous obtenons le code suivant (en fonction des différentes classes créées) :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using T4Practice.Classes;

namespace T4Practice
{
    public class ClassT4
    {
    
    public Class1 class1  {get; set; }
    
    public Class2 class2  {get; set; }
    
    }
}