Conhecendo o Text Template Transformation ToolKit (T4)

Os desenvolvedores gastamos muito tempo implementando código, e às vezes, acabam nos esquecendo de algumas ferramentas muito úteis para agilizar os trabalhos, por isso, veremos como trabalhar com o T4. Abordaremos apenas a criação de uma classe simples.

O que é o T4?

O T4 ou Text Template Transformation ToolKit é uma ferramenta de geração de Código fonte da Microsoft através de templates de texto, como o próprio nome diz. Esse recurso já existe desde o visual studio 2008, no entanto é possível realizar o download da ferramenta Domain-Specific Language Tools for Visual Studio 2005 que possibilita a utilização no visual studio 2005.

O T4 é uma mistura de blocos de texto e lógica de controle, que pode gerar um arquivo de texto. A lógica de controle é escrita como fragmentos de código de programa em Visual C# ou Visual Basic. O arquivo gerado é um arquivo texto que pode ser, por exemplo, uma página web, arquivos de resouce, ou código fonte em qualquer linguagem.

Existem dois tipos de T4:

• T4 Tempo de Execução: quando o arquivo T4 é chamado em tempo real pela aplicação, pode ser utilizado para criação de templates para páginas web.
• T4 Tempo de design: quando o arquivo T4 é utilizado pelo visual studio para gerar parte do código fonte ou outros recursos de sua aplicação.

Neste tutorial abordaremos o T4 Tempo de design.

Os modelos T4 são compostos das seguintes partes:

• elements that control how the template is processed.Directivas - elementos que controlam a forma como o modelo é processado.
• content that is copied directly to the output.Os blocos de texto - conteúdo que é copiado diretamente para a saída.
• Blocos de controle - o código do programa que insere os valores das variáveis ​​no texto, e controla partes condicionais ou repetidas do texto.

Apenas como forma de curiosidade, segue abaixo na Figura 1 uma ilustração do funcionamento do T4.

Figura 1. Demonstração do funcionamento T4

Nesse artigo vamos demonstrar como utilizar o T4 para gerar um pequeno código fonte, é lógico, será o famoso “Olá Mundo”. No entanto nesse artigo demonstraremos apenas como utilizar o T4, mas não abordaremos todo seu poder.

Vou demonstrar passo a passo como implementar o código no T4 para ele gere suas classes.

Abra o Visual Studio 2010, acesse o menu arquivo e clique em New Project. Digite “empty” na caixa de pesquisa e selecione BlankSolution e altere a propriedade Name para FirstTemplateT4, conforme mostra a Figura 2.

Figura 2. Criando uma nova solução.

Se olharmos no Solution Explorer veremos que foi criada uma solução vazia, então agora clique com o botão direito do mouse e escolha Add... e em seguida New Project.

Crie um projeto do Tipo Console Application e altere a propriedade Name para FirstTemplateT4, conforme demonstrado nas Figuras 3 e 4.

Figura 3. Solution Explorer.

Figura 4. Projeto Console Application

Agora vá ao Solution Explorer clique com o botão direito do mouse sobre o projeto FistTemplateT4 escolha Add.... Em seguida vá a New Item e isso irá adicionar um novo item, conforme demonstra a Figura 5.

Figura 5. Adicionando um novo item.

Escolha a opção Text Template e na propriedade Name coloque o nome desejado, no nosso exemplo colocamos T4_FirstTemplate. Repare que a extensão usada para arquivos do T4 é o .tt, conforme Figura 6.

Figura 6. Selecionando Text Template.

O visual Studio trará um template em branco com exceção as duas primeiras linhas onde traz as seguintes Diretivas:

1 - uma Diretiva de processamento que fornece modelos de compilação e opções de processamento, no caso da Listagem 1 estamos usando apenas três atributos: debug que indica se o código intermediário do visual studio 2010 quando for executar a transformação do texto para código fonte realizará um debug preciso ou não, hostspecific indica se seu código terá um host, e por último, a linguagem de programação que no nosso caso é C#.
Existem inúmeras diretivas de processamento, caso queira saber mais consulte no site http://msdn.microsoft.com/en-us/library/gg586945.aspx

Listagem 1. Diretiva de processamento

<#@ template debug="false" hostspecific="false" language="C#"#> =>

2. Nesta segunda diretiva temos a extensão de saída do arquivo, ou seja, qual será a extensão do arquivo gerado. No nosso caso vamos alterar para .cs, extensão de arquivos do C#. Confira a Listagem 2.

Listagem 2. Segunda diretiva

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

Confira a implementação das diretivas na Figura 7.

Figura 7. Mostrando as Diretivas no TextTemplate.

Agora vamos implementar o código para geração da nossa classe OlaMundo para que o T4 gere a classe, e com isso, possamos instanciar e utilizar a mesma. Para deixar um pouco mais interessante nossa classe Olá mundo, vamos criar outras cinco classes Olá mundo. Aí é que entra o T4, pois não precisaremos escrever as cinco, mas escreveremos apenas uma. Então mãos a massa.

Primeiro temos que declarar os namespaces que utilizaremos. Na Listagem 3 vemos o código.

Listagem 3. Declaração dos namespaces

<#@ import namespace="System.Collections"#> <#@ import namespace="System.Collections.Generic"#>

Agora precisamos criar uma lista de string para armazenar o que diferenciará as classes ola mundo e um método para alimentar essa lista. Esse método deve ser chamado no início do nosso arquivo .tt. Observe a Listagem 4.

Listagem 4. Lista de strings

<#+ public static List<String> _lString{ get; set; } public static void getString() { _lString = new List<String>(); _lString.Add("1"); _lString.Add("2"); _lString.Add("3"); _lString.Add("4"); _lString.Add("5"); } #>

No código acima temos dois detalhes: o primeiro é que todo código executável do T4 tem que estar entre os sinais , e segundo é que após o sinal

Agora vamos implementar a classe “OlaMundo”, conforme a Listagem 5.

Listagem 5. Implementação da classe OlaMundo

<# getString(); #> using System; namespace FirstTemplate { <# foreach(string item in _lString) { #> public class OlaMundo<#=item#> { public void Print() { Print(""); } public void Print(string text) { Console.WriteLine("Olá Mundo <#=item#> !!! ",text); Console.ReadKey(); } } <# } #> }

Vale ressaltar que no T4 deve conter todo o código, inclusive as usings necessárias para sua classe. No caso acima, por se tratar de uma classe simples, precisamos apenas da System, mas em casos mais complexo você deve incluir todas as demais classes.

Agora acesse o Solution Explorer, expanda o arquivo T4_FirstTemplate.tt para abrir o arquivo T4_FirstTemplate.cs. Nele você verá que o Visual Studio gerou o código da Classe, como podemos ver na Figura 8.

Figura 8. Classe gerada pelo T4.

Repare que você digitou o código de apenas uma classe e o visual studio se encarregou de gerar as cinco classes para você, através do foreach que fizemos.

Agora vá ate o Solution Explorer e com um duplo clique abra o arquivo program.cs. Acesse o método main para que possamos implementar o código da Listagem 6 para testar a classe que foi gerada pelo T4 e verificar se esta funcionando.

Listagem 6. Método main

static void Main(string[] args) { //Aqui vamos instanciar as classes OlaMundo1 e OlaMundo2 //para verificar seu funcionamento OlaMundo1 om = new OlaMundo1(); om.Print(); om.Print("Djonathan"); OlaMundo2 om2 = new OlaMundo2(); om2.Print(); om2.Print("Djonathan"); }

Agora com a implementação acima feita, acesse o menu Build e escolha a opção Build Solution ou simplesmente CTRL+Shift+B e rode a aplicação acessando o menu Debug Starting Debugging ou pressione F5. O resultado apresentado deve ser igual ao da Figura 9.

Figura 9. Resultado Final.

Concluindo, esse é apenas um exemplo para facilitar o entendimento da ferramenta T4. Lógico que para gerar a classe desse post não seria necessário utilizar o T4, mas utilizando Entity ou nHibernate ele pode ser muito útil para criar todas as suas classe de acesso a dados interfaces de uma forma dinâmica, o que simplifica e agiliza muito o desenvolvimento.

Com o T4 você pode gerar classes CRUD desde básicas até complexas de uma forma muito simples, além disso, quando utilizamos o Entity ele já implementa as classes para suas entidades, mas com o T4 o visual Studio traz o modelo e você pode alterar criando métodos que você ache necessário e adaptando ele para melhor atender sua aplicação.

Espero que tenham gostado deste artigo e que tenha sido útil a vocês.

Até a próxima!