Geração de código de tempo de design usando modelos de texto T4

Modelos de texto T4 de tempo de design lhe permite gerar código de programa e outros arquivos no seu Visual Studio project. Normalmente, você escreve os modelos para que eles podem variar o código que eles geram de acordo com a dados de um modelo. Um modelo é um arquivo ou banco de dados que contém informações importantes sobre requisitos do aplicativo.

Por exemplo, você poderia ter um modelo que define um fluxo de trabalho, como uma tabela ou um diagrama. A partir do modelo, você pode gerar o software que executa o fluxo de trabalho. Quando as necessidades de seus usuários mudam, é fácil discutir o novo fluxo de trabalho com os usuários. Regenerar o código do fluxo de trabalho é mais confiável do que atualizar o código manualmente.

Observação
A modelo é uma fonte de dados que descreve um aspecto específico de um aplicativo. Ele pode ser de qualquer forma, em qualquer tipo de arquivo ou banco de dados. Ele não tem de estar em qualquer formulário específico, como, por exemplo, um modelo de linguagem específica de domínio ou um modelo UML. Modelos típicos estão na forma de tabelas ou em arquivos XML.

Você provavelmente já está familiarizado com a geração de código. Quando você define os recursos em um .resx de arquivo em seu Visual Studio solução, um conjunto de classes e métodos é gerado automaticamente. O arquivo de recursos torna muito mais fácil e confiáveis para editar os recursos que seria se você tinha de editar as classes e métodos. Com os modelos de texto, você pode gerar o código da mesma forma de uma fonte de seu próprio design.

Um modelo de texto contém uma mistura de texto que você deseja gerar e código de programa que gera a variáveis partes do texto. O código de programa e permite que você repita ou omitir condicionalmente a partes do texto gerado. O texto gerado, si pode ser o código de programa que será parte do seu aplicativo de formulário.

Criando um modelo de texto T4 tempo de Design

Para criar um modelo de T4 de tempo de design em Visual Studio

1. Criar um Visual Studio de projeto ou abra um existente.

   Por exemplo, na arquivo , aponte para novae em seguida, clique em projeto.

2. Adicionar um arquivo de modelo de texto ao seu projeto e denomine-o NewTemplate.tt.

   Para fazer isso, em Solution Explorer, clique com o botão direito do projeto e aponte para Adde em seguida, clique em Novo Item. No Add New Item selecione caixa de diálogo Modelo de texto da modelos de painel. Nomeie o arquivo NewTemplate.tt.

   Observe que o Ferramenta personalizada é de propriedade do arquivo TextTemplatingFileGenerator.

3. Abra o arquivo. Já conterá as seguintes diretivas:

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

   Se você tiver adicionado o modelo para um Visual Basic o projeto, o atributo de idioma será "VB".

4. Adicione algum texto no final do arquivo. Por exemplo:

   Hello, world!
   

5. Salve o arquivo.

   Você pode ver um O aviso de segurança caixa de mensagem que lhe pede para confirmar que você deseja executar o modelo. Clique em OK.

6. Em Solution Explorer, expanda o nó NewTemplate.tt e você encontrará um arquivo chamado NewTemplate.txt. O arquivo contém o texto que você inseriu.

   Observação
   Se o seu projeto é um projeto de Visual Basic, você deve clicar em Mostrar todos os arquivos para ver o arquivo de saída de NewTemplate.txt.

O código de regeneração

Um modelo será executado, gerando o arquivo de subsidiária em qualquer um dos seguintes casos:

• Editar um modelo e, em seguida, altere o foco para um diferente Visual Studio janela.

• Salve o modelo.

• Clique em Transformar todos os modelos de na Solution Explorer barra de ferramentas. Isso transformará todos os modelos de Visual Studio solução.

• Clique com o botão direito um ou mais arquivos em Solution Explorer e, em seguida, clique em Ferramenta personalizado para executar. Use este método para transformar um conjunto de modelos selecionados.

Você também pode configurar um Visual Studio de projeto para que os modelos são executados quando os arquivos de dados, eles lidos tiverem sido alteradas. Para obter mais informações, consulte Regenerating the Code Automatically.

Gerando a variável de texto

Modelos de texto permitem que você use o código de programa para variar o conteúdo do arquivo gerado.

Para gerar o texto usando o código de programa

1. Alterar o conteúdo de .tt arquivo:

   <#@ template debug="false" hostspecific="false" language="C#" #>
   <#@ output extension=".txt" #>
   <#int top = 10;
   
   for (int i = 0; i<=top; i++) { #>
   The square of <#= i #> is <#= i*i #>
   <# } #>
   

   <#@ template debug="false" hostspecific="false" language="VB" #>
   <#@ output extension=".txt" #>
   <#Dim top As Integer = 10
   
   For i As Integer = 0 To top
   #>
       The square of <#= i #> is <#= i*i #>
   <#
   Next
   #>
   

2. Salve o arquivo .tt e inspecionar o txt gerado novamente. Ele lista os quadrados dos números de 0 a 9.

Observe que as instruções são colocadas dentro de <#...#>e único expressões dentro de <#=...#>. Para obter mais informações, consulte Escrever um modelo de texto T4.

Se você escrever o código de geração Visual Basic, o template deve conter a diretiva language="VB". "C#"é o padrão.

Geração de código ou recursos para sua solução

Você pode gerar os arquivos de programa que variam de acordo com um modelo. Um modelo é uma entrada como, por exemplo, um banco de dados, arquivo de configuração, o modelo UML, DSL modelo ou outra fonte. Geralmente você gerar vários arquivos de programa são do mesmo modelo. Para conseguir isso, você cria um arquivo de modelo para cada arquivo de programa gerado e todos os modelos leu o mesmo modelo.

Para gerar o código de programa ou recursos

1. Altere a diretiva de saída para gerar um arquivo do tipo apropriado, como, por exemplo,. cs,. vb,. resx ou. XML.

2. Inserir o código que irá gerar o código da solução que você precisa. Por exemplo, se você deseja gerar três declarações de campo de número inteiro em uma classe:

   <# var properties = new string [] {"P1", "P2", "P3"}; #>
   class MyGeneratedClass {
   <# 
     foreach (string propertyName in properties)
     { #>
     private int <#= propertyName #> = 0;
   <# } #>
   }
   

3. Salve o arquivo e inspecionar o arquivo gerado, que agora contém o código a seguir:

   class MyGeneratedClass {
     private int P1 = 0; 
     private int P2 = 0;
     private int P3 = 0;
   }
   

Observe que, como uma questão de boa prática, tendemos a separar o código de modelo em duas partes:

• Uma configuração ou a parte de coleta de dados, que define valores de variáveis, mas não contém blocos de texto. No exemplo, essa parte é a inicialização do properties.

• A parte de geração de texto (foreach(...){...} no exemplo), que usa os valores das variáveis.

Não é uma separação necessária, mas é um estilo que torna mais fácil de ler o modelo, reduzindo a complexidade da parte que inclui o texto.

Geração de código e texto gerado

Quando você gera o código de programa, é mais importante evitar confundir gerar código que executa em seu modelo e o código gerado resultante que se torna parte de sua solução. Os dois idiomas não tem o mesmo. Por exemplo, você pode usar um Visual C# modelo para gerar código em qualquer idioma.

Neste exemplo, um Visual Basic modelo gera Visual C# código:

<#@ template debug="false" hostspecific="false" language="VB" #>
<#@ output extension=".cs" #>
<# Dim properties = {"P1", "P2", "P3"} #>
class MyGeneratedClass {
<# 
   For Each propertyName As String In properties
#>
  private int <#= propertyName #> = 0;
<#
   Next
#>
}

Leitura de arquivos ou outras fontes

Para acessar um arquivo de modelo ou o banco de dados, o seu código de modelo pode usar assemblies como, por exemplo, System. XML. Para obter acesso a esses assemblies, você deve inserir diretivas como estes:

<#@ assembly name="System.Xml.dll" #>
<#@ import namespace="System.Xml" #>
<#@ import namespace="System.IO" #>

O assembly diretiva disponibiliza o assembly especificado para o seu código de modelo, da mesma maneira como a seção de referências de um Visual Studio project. Você precisa incluir uma referência a System. dll, que é referenciado automaticamente. O import diretiva permite que você use tipos sem usar seus nomes totalmente qualificados, da mesma maneira como o using diretiva em um arquivo de programa comum.

Por exemplo, após a importação de System.IO, você poderia escrever:

<# var properties = File.ReadLines("C:\\propertyList.txt");#>
...
<# foreach (string propertyName in properties) { #>
...

<# For Each propertyName As String In 
             File.ReadLines("C:\\propertyList.txt")
#>

Abrir um arquivo com um nome de caminho relativo

Para carregar um arquivo a partir de um local em relação ao modelo de texto, você pode usar this.Host.ResolvePath(). Para usá-la.Host, você deve definir hostspecific="true" na template:

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

Em seguida, você pode escrever, por exemplo:

<# string fileName = this.Host.ResolvePath("filename.txt");
  string [] properties = File.ReadLines(filename);
#>
...
<#  foreach (string propertyName in properties { #>
...

<# Dim fileName = Me.Host.ResolvePath("propertyList.txt")
   Dim properties = File.ReadLines(filename)
#>
...
<#   For Each propertyName As String In properties
...
#>

Você também pode usar this.Host.TemplateFile, que identifica o nome do arquivo atual do modelo.

The type of this.Host (in VB, Me.Host) is Microsoft.VisualStudio.TextTemplating.ITextTemplatingEngineHost.

Obtendo dados deVisual Studio

Para usar os serviços fornecidos no Visual Studio, pelo conjunto de hostSpecific atributo e carga a EnvDTE assembly. Por exemplo:

<#@ template hostspecific="true" language="C#" #>
<#@ output extension=".txt" #>
<#@ assembly name="EnvDTE" #>
<#
  IServiceProvider serviceProvider = (IServiceProvider)this.Host;
  EnvDTE.DTE dte = (EnvDTE.DTE) serviceProvider.GetService(typeof(EnvDTE.DTE));
#>

Number of projects in this VS solution:  <#= dte.Solution.Projects.Count #>

Regenerando o código automaticamente

Normalmente, vários arquivos em um Visual Studio solução são geradas com um modelo de entrada. Cada arquivo é gerado a partir de seu próprio modelo, mas os modelos que todos referir o mesmo modelo.

Se o modelo de origem for alterado, você deve executar novamente a todos os modelos na solução. Para fazer isso manualmente, clique em Transformar todos os modelos de na barra de ferramentas do Solution Explorer.

Se você tiver instalado o Visual Studio visualização e modelagem SDK, você pode ter todos os modelos transformados automaticamente sempre que você executar uma compilação. Para fazer isso, edite o arquivo de projeto (. csproj ou. vbproj) em um editor de texto e adicionar as seguintes linhas no final do arquivo, depois de qualquer outro <import> instruções:

<Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\TextTemplating\v10.0\Microsoft.TextTemplating.targets" />
<PropertyGroup>
   <TransformOnBuild>true</TransformOnBuild>
   <!-- Other properties can be inserted here -->
</PropertyGroup>

Para obter mais informações, consulte Geração de código em um processo de compilação.

Relatório de erros

Para colocar mensagens de erro e aviso na Visual Studio janela de erro, você pode usar estes métodos:

Error("An error message");
Warning("A warning message");

Convertendo um arquivo existente a um modelo

Um recurso útil dos modelos é que elas são muito parecido com os arquivos que geram, junto com alguns códigos de programa inserido. Isso sugere que um método útil de criação de um modelo. Primeiro crie um arquivo comum como protótipo, como um Visual C# de arquivo e apresentar gradativamente o código de geração que varia do arquivo resultante.

Para converter um arquivo existente a um modelo de design-time.

1. Para seu Visual Studio de projeto, adicione um arquivo do tipo que você deseja gerar, como um .cs, .vb, ou .resx arquivo.

2. Teste o novo arquivo para certificar-se de que ele funciona.

3. No Solution Explorer, altere a extensão de nome de arquivo para .tt.

4. Verifique se as seguintes propriedades da .tt arquivo:

   Ferramenta personalizada =	TextTemplatingFileGenerator
   Ação de compilação =	Nenhum

5. Insira as seguintes linhas no início do arquivo:

   <#@ template debug="false" hostspecific="false" language="C#" #>
   <#@ output extension=".cs" #>
   

   Se você deseja gravar o código de geração do seu modelo na Visual Basic, defina a language atributo para "VB" em vez de "C#".

   Definir o extension atributo para a extensão de nome de arquivo para o tipo de arquivo que você deseja gerar, por exemplo .cs, .resx, ou .xml.

6. Salve o arquivo.

   É criado um arquivo de subsidiária, com a extensão especificada. Suas propriedades são corretas para o tipo de arquivo. Por exemplo, o Build Action propriedade de um arquivo. cs seria compilar.

   Verifique se o arquivo gerado contém o mesmo conteúdo do arquivo original.

7. Identifica uma parte do arquivo que você deseja variar. Por exemplo, uma parte que aparece somente sob determinadas condições, ou a parte que é repetido, ou onde os valores específicos variam de acordo. Inserir a geração de código. Salve o arquivo e verifique se o arquivo da subsidiária seja gerado corretamente. Repita essa etapa.

Diretrizes para a geração de código

Consulte Diretrizes para a criação de modelos de texto T4.

Próximas etapas

Consulte também

Outros recursos

Diretrizes para a criação de modelos de texto T4

Histórico de alterações